Learn AI with Python · Lekcja

Autoenkodery do uczenia reprezentacji

Architektura enkoder–dekoder, wąskie gardło, strata rekonstrukcji, zastosowania w wykrywaniu anomalii.

Autoenkodery do uczenia reprezentacji to bezpłatna lekcja Learn AI with Python na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Learn AI with Python, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Learn AI with Python zawiera 4 lekcji w sumie.

Czym jest autoenkoder?

Autoenkoder uczy się kompresować dane do niewielkiego kodu, a następnie je odtwarzać. Składa się z dwóch części: enkodera, który kompresuje dane, oraz dekodera, który je odbudowuje. Zwężenie pośrodku zmusza model do nauczenia się tego, co jest najważniejsze.

import torch
import torch.nn as nn

Idea wąskiego gardła

Wąska warstwa środkowa to wąskie gardło lub kod latentny. Zmuszając wszystkie informacje do przejścia przez kilka liczb, sieć musi odrzucić szum i zachować istotną strukturę danych.

Budowanie enkodera

W przypadku obrazów 28x28 (784 piksele) enkoder stopniowo zmniejsza dane wejściowe: od 784 przez 256 do 64-wymiarowego kodu latentnego. Po każdej warstwie Linear następuje nieliniowość ReLU.

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

Budowanie dekodera

Dekoder odzwierciedla enkoder, rozwijając kod 64-wymiarowy z powrotem do 784 pikseli. Końcowa funkcja Sigmoid ogranicza wartości wyjściowe do zakresu [0,1], aby pasowały do znormalizowanych wartości pikseli.

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

Pełny autoenkoder

Połącz enkoder i dekoder w jeden moduł. Przebieg forward najpierw koduje, a następnie dekoduje dane, zwracając rekonstrukcję o takim samym kształcie jak dane wejściowe.

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)

Strata rekonstrukcji (MSE)

Celem uczenia jest samo wejście. Średni błąd kwadratowy mierzy, jak bardzo rekonstrukcja różni się od oryginału, piksel po pikselu. Minimalizowanie tej straty uczy wiernej kompresji.

criterion = nn.MSELoss()

x_flat = x.view(x.size(0), -1)
recon = model(x_flat)
loss = criterion(recon, x_flat)

Uczenie autoenkodera

Uczenie jest nienadzorowane: nie ma etykiet, są tylko dane wejściowe. Pętla ma standardową kolejność zero_grad, forward, backward, step, ale strata porównuje wyjście z wejściem.

optimizer.zero_grad()
recon = model(x_flat)
loss = criterion(recon, x_flat)
loss.backward()
optimizer.step()

Przestrzeń latentna

Po zakończeniu uczenia enkoder odwzorowuje każde wejście na punkt w przestrzeni latentnej. Podobne dane wejściowe trafiają blisko siebie, więc ten 64-wymiarowy kod jest wyuczoną, zwartą reprezentacją danych.

z = model.enc(x_flat)
print(z.shape)  # [batch, 64]

Wizualizacja za pomocą t-SNE

64-wymiarową przestrzeń latentną trudno zobaczyć. t-SNE odwzorowuje ją na płaszczyznę 2D w celu wizualizacji. Klastry na wykresie pokazują, że autoenkoder grupował podobne elementy, mimo że nigdy nie miał dostępu do etykiet.

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 label

Wykrywanie anomalii

Autoenkoder uczony na normalnych danych dobrze je rekonstruuje, ale ma trudności z anomaliami, których wcześniej nie widział. Duży błąd rekonstrukcji wskazuje wartość odstającą, co czyni autoenkoder skutecznym nienadzorowanym detektorem anomalii.

errors = ((model(data) - data) ** 2).mean(dim=1)
anomalies = errors > threshold

Dlaczego uczenie reprezentacji?

Najważniejszym rezultatem jest kod latentny: wyuczony wektor cech, którego można użyć do klasteryzacji, wizualizacji, wykrywania anomalii lub jako wejścia do innego modelu — wszystko to bez etykiet.

Szybkie sprawdzenie

Sprawdź swoją wiedzę na temat autoenkoderów.

Podsumowanie: autoenkodery

Zbudowano enkoder (784 do 256 do 64) oraz odzwierciedlający go dekoder, uczone za pomocą straty rekonstrukcji MSE i bez etykiet. Użyto kodu latentnego do uczenia reprezentacji, zwizualizowano go za pomocą t-SNE i wykrywano anomalie na podstawie dużego błędu rekonstrukcji.

Często zadawane pytania

Czy lekcja „Autoenkodery do uczenia reprezentacji” jest bezpłatna?

Tak — pełny tekst „Autoenkodery do uczenia reprezentacji” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Learn AI with Python, przejdź na CoddyKit PRO. Kurs Learn AI with Python zawiera 4 lekcji w sumie.

Co nauczysz się w „Autoenkodery do uczenia reprezentacji”?

Architektura enkoder–dekoder, wąskie gardło, strata rekonstrukcji, zastosowania w wykrywaniu anomalii. Ćwiczysz Learn AI with Python z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Learn AI with Python?

Nie wymagamy żadnego doświadczenia. Learn AI with Python w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „Autoenkodery do uczenia reprezentacji”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Learn AI with Python?

Tak. Każda lekcja Learn AI with Python zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Learn AI with Python