Lär Er AI med Python · Lektion

Variational Autoencoders (VAE)

ELBO-förlust, reparameteriseringstricket, utforskning av latent rymd, bildgenerering med VAE.

Lektion 2 av 413 steg

Variational Autoencoders (VAE) är en gratis lektion i Lär Er AI med Python på CoddyKit. Detta är lektion 2 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Lär Er AI med Python, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Lär Er AI med Python innehåller totalt 4 lektioner.

Från autoencoder till VAE

En vanlig autoencoder lär sig spridda punkter, så sampling av nya punkter ger skräp. En Variational Autoencoder (VAE) lär sig ett jämnt, kontinuerligt latent rum som går att sampla från och förvandlar det därmed till en riktig generativ modell.

Koda till en fördelning

I stället för en enda punkt ger en VAE-encoder en fördelning för varje indata: ett medelvärde mu och en logaritmisk varians log_var. Varje indata mappas till ett litet diffust område i det latenta rummet, inte till en enda punkt.

class Encoder(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc = nn.Linear(784, 256)
        self.fc_mu = nn.Linear(256, 64)
        self.fc_logvar = nn.Linear(256, 64)

Varför mu och log_var?

Vi förutsäger log_var i stället för variansen direkt, eftersom den kan vara vilket reellt tal som helst och inte har något positivitetskrav, samtidigt som den är numeriskt stabil. Genom exponentiering återfår vi variansen vid behov.

    def forward(self, x):
        h = torch.relu(self.fc(x))
        return self.fc_mu(h), self.fc_logvar(h)

Sampla latent z

För att avkoda måste vi sampla z från den förutsagda fördelningen. Ett naivt slumpmässigt uttag är inte differentierbart, så vi kan inte backpropagera genom det. Reparametriseringstricket löser detta.

Reparametriseringstricket

Skriv om samplinguttrycket som z = mu + eps * exp(0.5 * log_var), där eps är slumpmässigt brus. Nu ligger slumpen i eps (ingen gradient behövs), medan gradienterna flödar genom mu och log_var.

def reparameterize(mu, log_var):
    std = torch.exp(0.5 * log_var)
    eps = torch.randn_like(std)
    return mu + eps * std

Decodern

Decodern tar det samplade z och rekonstruerar bilden, precis som en vanlig autoencoder-decoder, genom att expandera 64 dimensioner tillbaka till 784 pixlar med en Sigmoid-utgång.

decoder = nn.Sequential(
    nn.Linear(64, 256),
    nn.ReLU(),
    nn.Linear(256, 784),
    nn.Sigmoid()
)

Rekonstruktionsförlustens term

Den första halvan av VAE-förlusten är rekonstruktionen: hur väl den avkodade bilden överensstämmer med indatan. Binär korsentropi (eller MSE) används för pixlarna.

recon_loss = nn.functional.binary_cross_entropy(
    recon, x, reduction="sum"
)

KL-divergenstermen

Den andra halvan är KL-divergensen, som drar varje kodad fördelning mot en standardnormalfördelning. Detta regulariserar det latenta rummet så att det blir jämnt och kontinuerligt, vilket möjliggör generering.

kl = -0.5 * torch.sum(1 + log_var - mu.pow(2) - log_var.exp())

ELBO-målfunktionen

VAE-modeller maximerar ELBO (Evidence Lower Bound), vilket motsvarar att minimera reconstruction + KL. Rekonstruktionen gör utdata trogen; KL-termen håller rummet välformat. Hela utmaningen är att balansera de två.

loss = recon_loss + kl
loss.backward()

Generera nya bilder

Eftersom det latenta rummet överensstämmer med en standardnormalfördelning kan Ni generera helt nya bilder genom att sampla z från N(0,1) och avkoda det, utan att någon indata behövs.

with torch.no_grad():
    z = torch.randn(16, 64)
    new_images = decoder(z)  # 16 generated samples

Varför VAE-modeller är viktiga

VAE-modeller ger ett välgrundat och jämnt latent rum som Ni kan interpolera i och sampla från. De utgör grunden för många generativa tekniker och lär ut den centrala idén att lära sig fördelningar, inte bara punkter.

Snabbkontroll

Testa förståelsen av VAE-modeller.

Besvara frågan i den interaktiva lektionen

Sammanfattning: Variational Autoencoders

Ni har lärt Er VAE: en encoder ger mu och log_var, och reparametriseringstricket z = mu + eps * exp(0.5 * log_var) gör sampling differentierbar. Förlusten är ELBO = reconstruction + KL. Genom att sampla z från N(0,1) och avkoda det går det att generera nya bilder.

Gratis att börja

Lär dig Python med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 53
Lektioner: 225

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Variational Autoencoders (VAE)” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Lär Er AI med Python, inklusive ”Variational Autoencoders (VAE)”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Lär Er AI med Python innehåller totalt 4 lektioner.

Vad lär jag mig i ”Variational Autoencoders (VAE)”?

ELBO-förlust, reparameteriseringstricket, utforskning av latent rymd, bildgenerering med VAE. Ni övar på Lär Er AI med Python med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Lär Er AI med Python?

Du behöver inga förkunskaper. Utbildningen i Lär Er AI med Python på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 4.

Hur lång tid tar lektionen ”Variational Autoencoders (VAE)”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Lär Er AI med Python-lektionen?

Ja. Varje Lär Er AI med Python-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

Autoencoders för representationsinlärning
Variational Autoencoders (VAE)
GAN-modeller: generator och diskriminator
Villkorade GAN-modeller och stilöverföring

← Tillbaka till Lär Er AI med Python