Autoencoder per l'apprendimento delle rappresentazioni
Architettura encoder-decoder, collo di bottiglia, loss di ricostruzione, applicazioni nel rilevamento delle anomalie
Autoencoder per l'apprendimento delle rappresentazioni è una lezione Learn AI with Python gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Learn AI with Python, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Learn AI with Python include 4 lezioni in totale.
Che cos'è un autoencoder?
Un autoencoder apprende a comprimere i dati in un codice compatto e a ricostruirli. È composto da due metà: un encoder che comprime e un decoder che ricostruisce. La compressione intermedia lo costringe a imparare ciò che conta.
import torch
import torch.nn as nnL'idea del collo di bottiglia
Lo strato centrale ristretto è il bottleneck o il codice latente. Costringendo tutte le informazioni a passare attraverso pochi numeri, la rete deve eliminare il rumore e conservare la struttura essenziale dei dati.
Costruire l'encoder
Per immagini 28x28 (784 pixel), l'encoder riduce le dimensioni dell'input un passaggio alla volta: da 784 a 256 fino a un codice latente di 64 dimensioni. Ogni layer Linear è seguito da una non linearità ReLU.
encoder = nn.Sequential(
nn.Linear(784, 256),
nn.ReLU(),
nn.Linear(256, 64)
)Costruzione del decodificatore
Il decodificatore rispecchia il codificatore, espandendo il codice a 64 dimensioni nuovamente in 784 pixel. Una Sigmoid finale comprime gli output nell'intervallo [0,1] per adattarli ai valori dei pixel normalizzati.
decoder = nn.Sequential(
nn.Linear(64, 256),
nn.ReLU(),
nn.Linear(256, 784),
nn.Sigmoid()
)L'autoencoder completo
Colleghi codificatore e decodificatore in un unico modulo. Il passaggio forward prima codifica e poi decodifica, restituendo una ricostruzione della stessa forma dell'input.
class AutoEncoder(nn.Module):
def __init__(self, enc, dec):
super().__init__()
self.enc, self.dec = enc, dec
def forward(self, x):
z = self.enc(x)
return self.dec(z)Perdita di ricostruzione (MSE)
L'obiettivo dell'addestramento è l'input stesso. L'errore quadratico medio misura quanto la ricostruzione si discosta dall'originale, pixel per pixel. Minimizzarlo insegna al modello a comprimere i dati fedelmente.
criterion = nn.MSELoss()
x_flat = x.view(x.size(0), -1)
recon = model(x_flat)
loss = criterion(recon, x_flat)Addestramento dell'autoencoder
L'addestramento è non supervisionato: nessuna etichetta, solo input. Il ciclo segue la sequenza standard zero_grad, forward, backward, step, ma la perdita confronta l'output con l'input.
optimizer.zero_grad()
recon = model(x_flat)
loss = criterion(recon, x_flat)
loss.backward()
optimizer.step()Lo spazio latente
Dopo l'addestramento, il codificatore mappa ogni input in un punto dello spazio latente. Gli input simili finiscono vicini, quindi questo codice a 64 dimensioni è una rappresentazione compatta dei dati appresa dal modello.
z = model.enc(x_flat)
print(z.shape) # [batch, 64]Visualizzazione con t-SNE
Lo spazio latente a 64 dimensioni è difficile da visualizzare. t-SNE lo proietta in 2D per il grafico. I cluster nel grafico mostrano che l'autoencoder ha raggruppato insieme gli elementi simili senza aver mai visto le etichette.
from sklearn.manifold import TSNE
codes = model.enc(all_data).detach().numpy()
proj = TSNE(n_components=2).fit_transform(codes)
# scatter plot proj colored by true labelRilevamento delle anomalie
Un autoencoder addestrato su dati normali li ricostruisce bene, ma ha difficoltà con le anomalie che non ha mai visto. Un errore di ricostruzione elevato segnala un valore anomalo, realizzando un potente rilevatore non supervisionato di anomalie.
errors = ((model(data) - data) ** 2).mean(dim=1)
anomalies = errors > thresholdPerché l'apprendimento delle rappresentazioni?
Il vero risultato è il codice latente: un vettore di caratteristiche appreso che può utilizzare per il clustering, la visualizzazione, il rilevamento delle anomalie o come input per un altro modello, il tutto appreso senza etichette.
Verifica rapida
Verifichi la propria comprensione degli autoencoder.
Riepilogo: autoencoder
Ha costruito un codificatore (da 784 a 256 a 64) e un decodificatore speculare, addestrato con la perdita di ricostruzione MSE e senza etichette. Ha usato il codice latente per l'apprendimento delle rappresentazioni, lo ha visualizzato con t-SNE e ha rilevato le anomalie tramite un errore di ricostruzione elevato.
Domande Frequenti
La lezione «Autoencoder per l'apprendimento delle rappresentazioni» è gratuita?
Sì — il testo completo di «Autoencoder per l'apprendimento delle rappresentazioni» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Learn AI with Python, passa a CoddyKit PRO. Il corso Learn AI with Python include 4 lezioni in totale.
Cosa imparerò in «Autoencoder per l'apprendimento delle rappresentazioni»?
Architettura encoder-decoder, collo di bottiglia, loss di ricostruzione, applicazioni nel rilevamento delle anomalie Eserciti Learn AI with Python con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Learn AI with Python?
Non è richiesta alcuna esperienza precedente. Learn AI with Python su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.
Quanto tempo richiede la lezione «Autoencoder per l'apprendimento delle rappresentazioni»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Learn AI with Python?
Sì. Ogni lezione Learn AI with Python include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Autoencoder per l'apprendimento delle rappresentazioni
- Autoencoder variazionali (VAE)
- GAN: generatore e discriminatore
- GAN condizionali e style transfer