Una panoramica degli Autoencoder Variationali

Panorama of Variational Autoencoders

Introduzione

I Variational Autoencoders (VAE) sono modelli generativi progettati esplicitamente per catturare la distribuzione di probabilità sottostante di un determinato dataset e generare nuovi campioni. Utilizzano un’architettura che comprende una struttura encoder-decoder. L’encoder trasforma i dati di input in una forma latente e il decoder cerca di ricostruire i dati originali basandosi su questa rappresentazione latente. Il VAE è programmato per minimizzare la dissimilarità tra i dati originali e quelli ricostruiti, consentendogli di comprendere la distribuzione dei dati sottostante e generare nuovi campioni che si conformano alla stessa distribuzione.

Uno dei vantaggi notevoli dei VAE è la loro capacità di generare nuovi campioni di dati simili ai dati di addestramento. Poiché lo spazio latente del VAE è continuo, il decoder può generare nuovi punti dati che si interpolano senza soluzione di continuità tra i punti dati di addestramento. I VAE trovano applicazioni in vari settori come la stima della densità e la generazione di testo.

Questo articolo è stato pubblicato come parte del Data Science Blogathon.

L’Architettura dei Variational Autoencoder

Un VAE di solito ha due componenti principali: una connessione dell’encoder e una connessione del decoder. Una rete encoder trasforma i dati di input in uno spazio segreto a bassa dimensione, spesso chiamato “codice segreto”.

Sono possibili diverse topologie di reti neurali, come reti neurali completamente connesse o reti neurali convoluzionali, per implementare le reti encoder. L’architettura scelta si basa sulle caratteristiche dei dati. La rete encoder produce parametri essenziali, come la media e la varianza di una distribuzione gaussiana, necessari per il campionamento e la generazione del codice latente.

Allo stesso modo, i ricercatori possono costruire la rete decoder utilizzando vari tipi di reti neurali, e il suo obiettivo è ricostruire i dati originali dal codice latente fornito.

Esempio di architettura VAE: fen

Un VAE comprende una rete encoder che mappa i dati di input in un codice latente e una rete decoder che esegue l’operazione inversa traducendo il codice latente in dati di ricostruzione. Attraverso questo processo di addestramento, il VAE apprende una rappresentazione latente ottimizzata che cattura le caratteristiche fondamentali dei dati, consentendo una ricostruzione precisa.

Intuizioni Sulla Regolarizzazione

Oltre agli aspetti architetturali, i ricercatori applicano la regolarizzazione al codice latente, rendendolo un elemento vitale dei VAE. Questa regolarizzazione impedisce l’overfitting incoraggiando una distribuzione uniforme del codice latente anziché semplicemente memorizzare i dati di addestramento.

La regolarizzazione non solo aiuta a generare nuovi campioni di dati che si interpolano senza soluzione di continuità tra i punti dati di addestramento, ma contribuisce anche alla capacità del VAE di generare nuovi dati simili ai dati di addestramento. Inoltre, questa regolarizzazione impedisce alla rete decoder di ricostruire perfettamente i dati di input, promuovendo l’apprendimento di una rappresentazione dei dati più generale che migliora la capacità del VAE di generare campioni di dati diversi.

Matematicamente, nei VAE, i ricercatori esprimono la regolarizzazione incorporando un termine di divergenza di Kullback-Leibler (KL) nella funzione di perdita. La rete encoder genera parametri (ad esempio, media e log-varianza) di una distribuzione gaussiana per il campionamento del codice latente. La funzione di perdita di un VAE include il calcolo della divergenza KL tra la distribuzione delle variabili latenti apprese e una distribuzione precedente, la distribuzione normale. I ricercatori incorporano il termine di divergenza KL per incoraggiare le variabili latenti a possedere distribuzioni simili alla distribuzione precedente.

ecco la formula per la divergenza KL:

KL(q(z∣x)∣∣p(z)) = E[log q(z∣x) − log p(z)]

In sintesi, la regolarizzazione incorporata nei VAE svolge un ruolo cruciale nel potenziare la capacità del modello di generare nuovi campioni di dati freschi riducendo il rischio di overfitting dei dati di addestramento.

Dettagli Matematici dei VAE

Framework Probabilistico e Assunzioni

Il framework probabilistico di un VAE può essere delineato come segue:

Variabili Latenti

Questo è cruciale per consentire la loro rappresentazione all’interno di un modello costruito utilizzando una distribuzione condizionale più semplice (tipicamente esponenziale) riguardo alla variabile osservata. È caratterizzato da una distribuzione di probabilità con due variabili: p(x, z). Mentre la variabile x è visibile nel dataset preso in considerazione, la variabile z non lo è. La distribuzione di probabilità totale può essere espressa come p(x, z) = p(x|z)p(z).

Variabili Osservate

Abbiamo una variabile osservata x, che si presume segua una distribuzione di verosimiglianza p(x|z) (ad esempio, una distribuzione di Bernoulli).

Distribuzione di Verosimiglianza

L(x, z) è una funzione che dipende da due variabili. Se fissiamo il valore di x, la funzione di verosimiglianza può essere intesa come una distribuzione che rappresenta la distribuzione di probabilità di z per quel particolare x fisso. Tuttavia, se fissiamo il valore di z, la funzione di verosimiglianza non dovrebbe essere considerata come una distribuzione per x. Nella maggior parte dei casi, non rispetta le caratteristiche di una distribuzione, come la somma a 1. Tuttavia, esistono determinati scenari in cui la funzione di verosimiglianza può soddisfare formalmente i criteri di una distribuzione e soddisfare l’esigenza di sommare a 1.

La distribuzione combinata delle variabili latenti e osservabili è la seguente: p(x,z) = p(x|z)p(z). Una distribuzione di probabilità congiunta presenta la distribuzione di probabilità per più variabili casuali.

Lo scopo principale di un VAE è comprendere la vera distribuzione posteriore delle variabili latenti, indicata come p(z|x). Un VAE realizza questo impiegando una rete di codifica per approssimare la vera distribuzione posteriore con un’approssimazione appresa q(z|x).

Distribuzione Posteriore

Nella statistica bayesiana, una probabilità posteriore si riferisce alla probabilità aggiornata o aggiustata di un evento che avviene alla luce di nuove informazioni acquisite. Aggiorna la probabilità a priori applicando il teorema di Bayes per calcolare la probabilità posteriore.

Il VAE apprende i parametri del modello massimizzando il Lower Bound dell’Evidence (ELBO):

ELBO = E[log(p(x|z))] – KL(q(z|x)||p(z))

ELBO è composto da due termini. Il primo termine è il termine di ricostruzione, che calcola la capacità del VAE di recuperare correttamente i dati di input. Il secondo termine, la varianza KL, definisce la differenza tra la distribuzione posteriore stimata (q(z|x)) e la distribuzione a priori (p(z)).

Impiegando un framework probabilistico, i modelli VAE generano i dati assumendo che i dati di input da uno spazio latente siano su specifiche distribuzioni probabilistiche. L’obiettivo è apprendere la vera distribuzione posteriore massimizzando la verosimiglianza dei dati di input.

Formulazione dell’Inferenza Variazionale

La formulazione dell’Inferenza Variazionale in un VAE è la seguente:

Distribuzione posteriore approssimata: Abbiamo un’approssimazione della distribuzione posteriore q(z|x).
Distribuzione posteriore reale: Abbiamo la vera distribuzione posteriore p(z|x).

L’obiettivo è trovare una distribuzione simile (q(z|x)) che approssimi il più possibile la vera distribuzione (p(z|x)), utilizzando il metodo della divergenza KL.

L’equazione della varianza KL confronta due distribuzioni di probabilità, q(z|x) e p(z|x), per misurare le loro differenze.

Durante l’addestramento del VAE, cerchiamo di minimizzare la divergenza KL aumentando l’evidence del Lower Bound (ELBO), una combinazione del termine di ricostruzione e della divergenza KL. Il termine di ricostruzione valuta la capacità del modello di ricostruire i dati di input, mentre la divergenza KL misura la differenza tra le distribuzioni approssimate e reali.

Reti Neurali nel Modello

Le reti neurali sono comunemente utilizzate per implementare i VAE, in cui sia il componente di codifica che il componente di decodifica sono implementati come reti neurali. Durante il processo di addestramento, il VAE regola i parametri delle reti di codifica e decodifica per minimizzare due componenti chiave: l’errore di ricostruzione e la divergenza KL tra la distribuzione variazionale e la vera distribuzione posteriore. Questo compito di ottimizzazione viene spesso realizzato utilizzando tecniche come la discesa del gradiente stocastico o altri algoritmi di ottimizzazione adatti.

Esecuzione dell’Autoencoder Variazionale

Prima di entrare nella configurazione di un Autoencoder Variazionale (VAE), è fondamentale comprendere prima i concetti fondamentali. Sebbene l’implementazione del VAE possa essere complessa, possiamo semplificare l’apprendimento seguendo una struttura logica e coerente.

Il nostro approccio prevedrà l’introduzione graduale dei concetti fondamentali e l’approfondimento progressivo dei dettagli di implementazione. Adotteremo un approccio pratico per migliorare la comprensione e fornire esempi illustrativi lungo il percorso di apprendimento.

Preparazione dei dati

Il codice fornito include il caricamento del dataset MNIST, un dataset ampiamente utilizzato per compiti di apprendimento automatico e visione artificiale. Questo dataset è composto da 60.000 immagini in scala di grigi di cifre scritte a mano (0-9), ognuna delle quali ha una dimensione di 28×28 pixel, insieme alle rispettive etichette che indicano la cifra rappresentata in ciascuna immagine. Ciò ci permette di collegare le immagini alle rispettive categorie o nomi. Per preparare i dati di input per l’addestramento, il codice applica la normalizzazione dividendo tutti i valori dei pixel per 255. Inoltre, modifichiamo la forma dei dati di input per incorporare una dimensione di batch. Questo passaggio di pre-elaborazione assicura che i dati siano formattati correttamente per l’addestramento del modello.

import tensorflow as tf
import numpy as np

(x_train, y_train)
,(x_test, y_test) =
tf.keras.datasets.mnist.load_data()

# Normalizza i dati di input
x_train = x_train / 255.
# Modifica la forma dei dati di input per avere una dimensione di batch aggiuntiva
x_train = x_train.reshape((-1, 28*28))
x_test = x_test.reshape((-1, 28*28))

Definizione del modello

Nel modello VAE, abbiamo un encoder e un decoder che lavorano insieme. L’encoder mappa l’immagine di input allo spazio latente utilizzando due livelli densi con una funzione di attivazione ReLU. D’altra parte, il decoder prende il vettore latente in input e ricostruisce l’immagine originale utilizzando due livelli densi.

input_dim = 28*28
hidden_dim = 512
latent_dim = 128

Architettura dell’encoder

encoder_input = tf.keras.Input(shape=(input_dim,))
encoder_hidden = tf.keras.layers.Dense(hidden_dim, activation='relu')(encoder_input)
latent = tf.keras.layers.Dense(latent_dim)(encoder_hidden)
encoder = tf.keras.Model(encoder_input, latent)

Architettura del decoder

decoder_input = tf.keras.Input(shape=(latent_dim,))
decoder_hidden = tf.keras.layers.Dense(hidden_dim, activation='relu')(decoder_input)
decoder_output = tf.keras.layers.Dense(input_dim)(decoder_hidden)
decoder = tf.keras.Model(decoder_input, decoder_output)

Architettura VAE

inputs = tf.keras.Input(shape=(input_dim,))
latent = encoder(inputs)
outputs = decoder(latent)
vae = tf.keras.Model(inputs, outputs)

Addestramento del modello

Per addestrare il VAE, utilizziamo l’ottimizzatore Adam e la funzione di perdita binary cross-entropy. L’addestramento viene eseguito in mini-batch, in cui si calcola la perdita e si propagano i gradienti per ogni immagine. Ripetere questo processo.

loss_fn = tf.keras.losses.BinaryCrossentropy()
optimizer = tf.keras.optimizers.Adam()

num_epochs = 50
for epoch in range(num_epochs):
    for x in x_train:
     
        x = x[tf.newaxis, ...]
        
        with tf.GradientTape() as tape:
        
            reconstructed = vae(x)
            
           
            loss = loss_fn(x, reconstructed)
            
       
        grads = tape.gradient(loss, vae.trainable_variables)
        optimizer.apply_gradients(zip(grads, vae.trainable_variables))
        
    print(f'Epoch {epoch+1}/{num_epochs}, Loss: {loss.numpy():.4f}')

Output:

Epoch 1: Loss - 0.3559
Epoch 2: Loss - 0.3550
.
.
.

Genera campioni

In questo codice aggiornato, ridefiniamo la variabile latent_samples con una forma di (5, latent_dim), consentendo di generare cinque campioni casuali anziché 10. Abbiamo anche modificato il ciclo for per iterare cinque volte, visualizzando cinque campioni generati anziché 10. Inoltre, regoliamo la funzione subplot per disporre i campioni generati in una griglia con una riga e cinque colonne.

# Genera campioni
latent_samples = tf.random.normal(shape=(5, latent_dim))
generated_samples = decoder(latent_samples)

# Visualizza i campioni generati
import matplotlib.pyplot as plt

for i in range(5):
    plt.subplot(1, 5, i+1)
    plt.imshow(generated_samples[i].numpy().reshape(28, 28), cmap='gray')
    plt.axis('off')
    
plt.show()

output:

Quando si esegue questo codice, verrà generata un’immagine che rappresenta cinque immagini simili a quelle dell’insieme di test MNIST. Il sistema mostrerà queste fotografie in un’organizzazione a griglia con una riga e cinque colonne. Le immagini verranno mostrate in scala di grigi, utilizzando la mappa dei colori ‘grey’, senza assi.

Visualizzazione dello spazio latente

Per ottenere una comprensione dello spazio latente di un VAE, è possibile seguire questi passaggi:

Utilizzare il VAE per codificare i punti dei dati di addestramento, proiettandoli nello spazio latente.
Utilizzare una tecnica di riduzione della dimensionalità come t-SNE per mappare lo spazio latente ad alta dimensionalità in uno spazio bidimensionale adatto alla visualizzazione.
Tracciare i punti dei dati nello spazio bidimensionale, consentendo una visualizzazione esplorativa dello spazio latente.

Seguendo questo processo, è possibile visualizzare ed comprendere in modo efficace la struttura sottostante e la distribuzione dello spazio latente nel VAE.

import tensorflow as tf
from sklearn.manifold import TSNE


latent_vectors = encoder(x_train).numpy()


latent_2d = TSNE(n_components=2).fit_transform(latent_vectors)

# Tracciamento dello spazio latente
plt.scatter(latent_2d[:, 0], latent_2d[:, 1], c=y_train, cmap='viridis')
plt.colorbar()
plt.show()

output:

Ottenere una comprensione della struttura e dell’organizzazione dei dati addestrati su un Variational Autoencoder (VAE) mediante la visualizzazione del suo spazio latente. Questa tecnica di visualizzazione offre un mezzo prezioso per comprendere i modelli sottostanti e le relazioni all’interno dei dati.

Conclusioni

Un variational autoencoder (VAE) è una forma avanzata di autoencoder che incorpora tecniche di regolarizzazione per mitigare l’overfitting e garantire proprietà desiderabili nello spazio latente per processi generativi efficaci. Funzionando come un sistema generativo, i VAE condividono un obiettivo simile alle reti generative avversariali. Come un autoencoder convenzionale, un VAE è composto da un’encoder e un decoder. Il suo addestramento mira a ridurre l’errore di ricostruzione tra i dati codificati-decodificati e l’input originale.

Punti chiave

I variational autoencoder (VAE) possono imparare a ricostruire e generare nuovi campioni da un dataset fornito.
Utilizzando uno spazio latente, i VAE possono rappresentare i dati in modo continuo e uniforme, facilitando la generazione di variazioni dei dati di input con transizioni fluide.
L’architettura di un VAE è composta da una rete di encoder che mappa i dati di input nello spazio latente, una rete di decoder responsabile della ricostruzione dei dati dallo spazio latente e una funzione di perdita che combina una perdita di ricostruzione e un termine di regolarizzazione.
I VAE hanno dimostrato la loro utilità nella generazione di immagini, nella rilevazione di anomalie e nelle attività di apprendimento semi-supervisionato.

Domande frequenti

I media mostrati in questo articolo non sono di proprietà di Analytics Vidhya e vengono utilizzati a discrezione dell’autore.

Architecture,blogathon,dataset,distribution,image,regularization,training,training data

Il responsabile della fiducia e della sicurezza di OpenAI si dimette Qual è l’impatto su ChatGPT?

Questo articolo sull’IA mostra una strada per creare grandi quantità di dati di istruzione con livelli di complessità variabili utilizzando LLM al posto degli esseri umani