Autoenkodery splotowe
Splotowe sieci neuronowe pobierają dwuwymiarową instancję danych o strukturze przestrzennej (obraz) i przetwarzają ją do momentu uzyskania pewnego rodzaju jednowymiarowej reprezentacji wektorowej. Nasuwa się pytanie, czy jeśli można nauczyć się mapowania z macierzy obrazu na reprezentację wektorową, być może można nauczyć się mapowania z tej reprezentacji wektorowej z powrotem na obraz. W tym artykule demonstracyjnym przyjrzymy się właśnie temu.
Warunki wstępne
Aby zapoznać się z tym samouczkiem, wymagana jest podstawowa znajomość kodu Pythona i sieci neuronowych. Polecamy ten artykuł średnio zaawansowanym i zaawansowanym programistom z doświadczeniem w tworzeniu nowatorskich architektur.
Kod zawarty w tym artykule można wykonać na zwykłym domowym komputerze PC lub na platformie DigitalOcean Droplet.
Convnets jako ekstraktory cech
W poprzednich artykułach poruszałem fakt, że warstwy splotu w sieci służą do wydobywania cech z obrazów. Cechy te są następnie przekazywane do warstw liniowych, które dokonują właściwej klasyfikacji (wyjątki dotyczą architektur, które wykorzystują warstwy splotu 1 x 1 do próbkowania w dół).
Rozważmy VGG-16 z jego architekturą przedstawioną powyżej, od warstwy wejściowej aż do punktu, w którym połączone mapy obiektów 7 x 7 x 512 są spłaszczane, aby utworzyć wektor o rozmiarze 25 088 elementów: ta część sieć służy jako ekstraktor funkcji. Zasadniczo obraz o wymiarach 224 x 224 zawierający łącznie 50 176 pikseli jest przetwarzany w celu utworzenia wektora cech zawierającego 25 088 elementów, a ten wektor cech jest następnie przekazywany do warstw liniowych w celu klasyfikacji.
Ponieważ te cechy są wyodrębniane przez sieć konwersyjną, logiczne jest założenie, że inna sieć konwersyjna mogłaby ewentualnie zrozumieć te cechy i złożyć z powrotem oryginalny obraz, do którego te cechy należą, zasadniczo odwracając proces ekstrakcji cech. Zasadniczo właśnie to robi Autoenkoder.
Struktura autoenkodera
Jak stwierdzono w poprzedniej sekcji, autoenkodery to architektury głębokiego uczenia się, które potrafią rekonstruować instancje danych na podstawie ich wektorów cech. Działają na wszelkiego rodzaju danych, ale ten artykuł dotyczy przede wszystkim ich zastosowania na danych obrazu. Autoenkoder składa się z 3 głównych elementów; mianowicie koder, wąskie gardło i dekoder.
Koder
Koder, pierwsza część autoenkodera, to sieć, która działa w szczególności jako ekstraktor funkcji. Jego podstawową funkcją jest pomoc w wyodrębnieniu najważniejszych cech z obrazów i zwróceniu ich w postaci wektora.
Szyjka
Umieszczone tuż za koderem wąskie gardło, zwane także warstwą kodu, służy jako dodatkowa warstwa, która pomaga skompresować wyodrębnione funkcje do mniejszej reprezentacji wektorowej. Ma to na celu utrudnienie dekoderowi zrozumienia funkcji i zmuszenie go do nauki bardziej złożonych mapowań.
Dekoder
Ostatnia część autoenkodera, dekoder, to połączenie, które próbuje zrozumieć cechy pochodzące z kodera, które zostały następnie skompresowane w wąskim gardle, aby zrekonstruować oryginalny obraz takim, jaki był.
Szkolenie autoenkodera
W tej sekcji zaimplementujemy od podstaw autoenkoder w PyTorch i przeszkolimy go na konkretnym zbiorze danych.
Zacznijmy od szybkiego zaimportowania naszych wymaganych pakietów.
# article dependencies
import torch
import torch.nn as nn
import torch.nn.functional as F
import torchvision
import torchvision.transforms as transforms
import torchvision.datasets as Datasets
from torch.utils.data import Dataset, DataLoader
import numpy as np
import matplotlib.pyplot as plt
import cv2
from tqdm.notebook import tqdm
from tqdm import tqdm as tqdm_regular
import seaborn as sns
from torchvision.utils import make_grid
import random
configuring device
if torch.cuda.is_available():
device = torch.device('cuda:0')
print('Running on the GPU')
else:
device = torch.device('cpu')
print('Running on the CPU')
Przygotowanie danych
Na potrzeby tego artykułu wykorzystamy zbiór danych CIFAR-10 do szkolenia autoenkodera splotowego. Można go załadować, jak pokazano w komórce kodu poniżej.
# loading training data
training_set = Datasets.CIFAR10(root='./', download=True,
transform=transforms.ToTensor())
loading validation data
validation_set = Datasets.CIFAR10(root='./', download=True, train=False,
transform=transforms.ToTensor())
Następnie musimy wyodrębnić tylko obrazy ze zbioru danych. Ponieważ próbujemy nauczyć autoenkoder rekonstruowania obrazów, celem nie będą etykiety klas, ale same obrazy. Obraz z każdej klasy jest również wyodrębniany i przechowywany w obiekcie „test_images” tylko w celach wizualizacyjnych, więcej o tym później.
def extract_each_class(dataset):
"""
This function searches for and returns
one image per class
"""
images = []
ITERATE = True
i = 0
j = 0
while ITERATE:
for label in tqdm_regular(dataset.targets):
if label==j:
images.append(dataset.data[i])
print(f'class {j} found')
i+=1
j+=1
if j==10:
ITERATE = False
else:
i+=1
return images
extracting training images
training_images = [x for x in training_set.data]
extracting validation images
validation_images = [x for x in validation_set.data]
extracting test images for visualization purposes
test_images = extract_each_class(validation_set)
Teraz musimy zdefiniować klasę zbioru danych PyTorch, aby móc używać obrazów jako tensorów. To, wraz z tworzeniem instancji klas, odbywa się w komórce kodu poniżej.
# defining dataset class
class CustomCIFAR10(Dataset):
def __init__(self, data, transforms=None):
self.data = data
self.transforms = transforms
def __len__(self):
return len(self.data)
def __getitem__(self, idx):
image = self.data[idx]
if self.transforms!=None:
image = self.transforms(image)
return image
creating pytorch datasets
training_data = CustomCIFAR10(training_images, transforms=transforms.Compose([transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]))
validation_data = CustomCIFAR10(validation_images, transforms=transforms.Compose([transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]))
test_data = CustomCIFAR10(test_images, transforms=transforms.Compose([transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]))
Architektura autoenkodera
Na potrzeby tego artykułu zdefiniowano niestandardową architekturę autoenkodera splotowego, jak pokazano poniżej. Architektura ta została zaprojektowana do współpracy ze zbiorem danych CIFAR-10, ponieważ jej koder pobiera obrazy o wymiarach 32 x 32 pikseli w 3 kanałach i przetwarza je do momentu uzyskania 64 map obiektów 8 x 8 wytworzony.
Te mapy obiektów są następnie spłaszczane w celu uzyskania wektora składającego się z 4096 elementów, który następnie jest kompresowany do zaledwie 200 elementów w wąskim gardle. Dekoder pobiera tę 200-elementową reprezentację wektorową i przetwarza ją poprzez transponowany splot, aż jako wynik zostanie zwrócony obraz 3 x 32 x 32.
Zdefiniowana powyżej architektura jest zaimplementowana w komórce kodu poniżej. Parametr „latent_dim” w tym przypadku odnosi się do rozmiaru wąskiego gardła, który określiliśmy na 200.
# defining encoder
class Encoder(nn.Module):
def __init__(self, in_channels=3, out_channels=16, latent_dim=200, act_fn=nn.ReLU()):
super().__init__()
self.net = nn.Sequential(
nn.Conv2d(in_channels, out_channels, 3, padding=1), # (32, 32)
act_fn,
nn.Conv2d(out_channels, out_channels, 3, padding=1),
act_fn,
nn.Conv2d(out_channels, 2*out_channels, 3, padding=1, stride=2), # (16, 16)
act_fn,
nn.Conv2d(2*out_channels, 2*out_channels, 3, padding=1),
act_fn,
nn.Conv2d(2*out_channels, 4*out_channels, 3, padding=1, stride=2), # (8, 8)
act_fn,
nn.Conv2d(4*out_channels, 4*out_channels, 3, padding=1),
act_fn,
nn.Flatten(),
nn.Linear(4*out_channels*8*8, latent_dim),
act_fn
)
def forward(self, x):
x = x.view(-1, 3, 32, 32)
output = self.net(x)
return output
defining decoder
class Decoder(nn.Module):
def __init__(self, in_channels=3, out_channels=16, latent_dim=200, act_fn=nn.ReLU()):
super().__init__()
self.out_channels = out_channels
self.linear = nn.Sequential(
nn.Linear(latent_dim, 4*out_channels*8*8),
act_fn
)
self.conv = nn.Sequential(
nn.ConvTranspose2d(4*out_channels, 4*out_channels, 3, padding=1), # (8, 8)
act_fn,
nn.ConvTranspose2d(4*out_channels, 2*out_channels, 3, padding=1,
stride=2, output_padding=1), # (16, 16)
act_fn,
nn.ConvTranspose2d(2*out_channels, 2*out_channels, 3, padding=1),
act_fn,
nn.ConvTranspose2d(2*out_channels, out_channels, 3, padding=1,
stride=2, output_padding=1), # (32, 32)
act_fn,
nn.ConvTranspose2d(out_channels, out_channels, 3, padding=1),
act_fn,
nn.ConvTranspose2d(out_channels, in_channels, 3, padding=1)
)
def forward(self, x):
output = self.linear(x)
output = output.view(-1, 4*self.out_channels, 8, 8)
output = self.conv(output)
return output
defining autoencoder
class Autoencoder(nn.Module):
def __init__(self, encoder, decoder):
super().__init__()
self.encoder = encoder
self.encoder.to(device)
self.decoder = decoder
self.decoder.to(device)
def forward(self, x):
encoded = self.encoder(x)
decoded = self.decoder(encoded)
return decoded
Jak zwykle musimy teraz zdefiniować klasę, która sprawi, że szkolenie i walidacja będą bardziej płynne. W tym przypadku, ponieważ uczymy modelu generatywnego, straty mogą nie nieść zbyt wielu informacji. Ogólnie rzecz biorąc, chcemy, aby straty zostały zredukowane, ale możemy również użyć wartości strat, aby zobaczyć, jak dobrze autoenkoder rekonstruuje obrazy dla każdej epoki. Z tego powodu zamieściłem blok wizualizacji, jak pokazano poniżej.
class ConvolutionalAutoencoder():
def __init__(self, autoencoder):
self.network = autoencoder
self.optimizer = torch.optim.Adam(self.network.parameters(), lr=1e-3)
def train(self, loss_function, epochs, batch_size,
training_set, validation_set, test_set):
# creating log
log_dict = {
'training_loss_per_batch': [],
'validation_loss_per_batch': [],
'visualizations': []
}
# defining weight initialization function
def init_weights(module):
if isinstance(module, nn.Conv2d):
torch.nn.init.xavier_uniform_(module.weight)
module.bias.data.fill_(0.01)
elif isinstance(module, nn.Linear):
torch.nn.init.xavier_uniform_(module.weight)
module.bias.data.fill_(0.01)
# initializing network weights
self.network.apply(init_weights)
# creating dataloaders
train_loader = DataLoader(training_set, batch_size)
val_loader = DataLoader(validation_set, batch_size)
test_loader = DataLoader(test_set, 10)
# setting convnet to training mode
self.network.train()
self.network.to(device)
for epoch in range(epochs):
print(f'Epoch {epoch+1}/{epochs}')
train_losses = []
#------------
# TRAINING
#------------
print('training...')
for images in tqdm(train_loader):
# zeroing gradients
self.optimizer.zero_grad()
# sending images to device
images = images.to(device)
# reconstructing images
output = self.network(images)
# computing loss
loss = loss_function(output, images.view(-1, 3, 32, 32))
# calculating gradients
loss.backward()
# optimizing weights
self.optimizer.step()
#--------------
# LOGGING
#--------------
log_dict['training_loss_per_batch'].append(loss.item())
#--------------
# VALIDATION
#--------------
print('validating...')
for val_images in tqdm(val_loader):
with torch.no_grad():
# sending validation images to device
val_images = val_images.to(device)
# reconstructing images
output = self.network(val_images)
# computing validation loss
val_loss = loss_function(output, val_images.view(-1, 3, 32, 32))
#--------------
# LOGGING
#--------------
log_dict['validation_loss_per_batch'].append(val_loss.item())
#--------------
# VISUALISATION
#--------------
print(f'training_loss: {round(loss.item(), 4)} validation_loss: {round(val_loss.item(), 4)}')
for test_images in test_loader:
# sending test images to device
test_images = test_images.to(device)
with torch.no_grad():
# reconstructing test images
reconstructed_imgs = self.network(test_images)
# sending reconstructed and images to cpu to allow for visualization
reconstructed_imgs = reconstructed_imgs.cpu()
test_images = test_images.cpu()
# visualisation
imgs = torch.stack([test_images.view(-1, 3, 32, 32), reconstructed_imgs],
dim=1).flatten(0,1)
grid = make_grid(imgs, nrow=10, normalize=True, padding=1)
grid = grid.permute(1, 2, 0)
plt.figure(dpi=170)
plt.title('Original/Reconstructed')
plt.imshow(grid)
log_dict['visualizations'].append(grid)
plt.axis('off')
plt.show()
return log_dict
def autoencode(self, x):
return self.network(x)
def encode(self, x):
encoder = self.network.encoder
return encoder(x)
def decode(self, x):
decoder = self.network.decoder
return decoder(x)
Gdy wszystko jest ustawione, możemy następnie utworzyć instancję naszego autoenkodera jako członka klasy autoenkodera splotowego, którą zdefiniowaliśmy poniżej, używając parametrów określonych w poniższej komórce kodu.
# training model
model = ConvolutionalAutoencoder(Autoencoder(Encoder(), Decoder()))
log_dict = model.train(nn.MSELoss(), epochs=10, batch_size=64,
training_set=training_data, validation_set=validation_data,
test_set=test_data)
Już pod koniec pierwszej epoki było oczywiste, że nasz dekoder zaczął rozwijać umiejętność rekonstrukcji obrazów wprowadzanych do kodera, mimo że miał dostęp jedynie do skompresowanej reprezentacji wektora cech składającej się z 200 elementów. Zrekonstruowane obrazy są coraz bardziej szczegółowe, aż do 10. epoki.
Patrząc na straty w zakresie szkoleń i walidacji, autoenkoder mógłby nadal nieco zyskać na większej liczbie okresów uczenia się, ponieważ jego straty nadal mają tendencję spadkową. Dotyczy to bardziej utraty walidacji niż utraty szkoleń, która wydaje się ustabilizować.
Wąskie gardło i szczegóły
W jednej z poprzednich sekcji wspomniałem, że warstwa kodu wąskiego gardła służy do dalszej kompresji wektora cech, aby zmusić dekoder do nauczenia się bardziej złożonego i możliwego do uogólnienia mapowania. Z drugiej strony należy szukać równowagi, ponieważ wielkość kompresji w warstwie kodu wpływa również na to, jak dobrze dekoder może zrekonstruować obraz.
Im mniejsza reprezentacja wektorowa przekazywana do dekodera, tym mniej cech obrazu ma dekoder i tym mniej szczegółowa będzie jego rekonstrukcja. W tym samym sensie im większa reprezentacja wektorowa przekazywana jest do dekodera, tym do większej liczby funkcji obrazu ma on dostęp i tym bardziej szczegółowa będzie jego rekonstrukcja. Podążając tym tokiem myślenia, wytrenujmy tę samą architekturę autoenkodera, ale tym razem używając wąskiego gardła o rozmiarze 1000.
# training model
model = ConvolutionalAutoencoder(Autoencoder(Encoder(latent_dim=1000), Decoder(latent_dim=1000)))
log_dict = model.train(nn.MSELoss(), epochs=10, batch_size=64,
training_set=training_data, validation_set=validation_data,
test_set=test_data)
Z wizualizacji generowanych w poszczególnych epokach od razu widać, że dekoder lepiej radzi sobie z rekonstrukcją obrazów pod względem szczegółowości i dokładności wizualnej. Dzieje się tak dlatego, że nowy dekoder ma dostęp do większej liczby funkcji, ponieważ oryginalny wektor cech składający się z 4096 elementów jest teraz próbkowany do 1000 elementów zamiast 200.
Epoka 1 (na górze) vs Epoka 10 (na dole).
Ponownie, autoenkoder mógłby skorzystać na kilku kolejnych epokach szkolenia. Straty związane z trenowaniem i walidacją nadal wykazują tendencję spadkową, a nachylenia są bardziej strome niż te, które zaobserwowaliśmy podczas trenowania naszego autoenkodera z wąskim gardłem składającym się z zaledwie 200 elementów.
Porównanie wąskich gardeł o wielkości 200 i 1000 w 10. epoce wyraźnie pokazuje, że obrazy wygenerowane przy wąskim gardle składającym się z 1000 elementów są wyraźniejsze/bardziej szczegółowe niż obrazy wygenerowane przy wąskim gardle składającym się z 200 elementów.
Wąskie gardło 200 (na górze) i wąskie gardło 1000 (na dole), oba w 10. epoce.
Trening do absolutnego udoskonalenia
W którym momencie autoenkoder splotowy jest optymalnie szkolony? Na podstawie dwóch wyszkolonych przez nas autoenkoderów możemy zaobserwować, że rekonstrukcje w 10. epoce są nadal niewyraźne, mimo że nasze wykresy strat zaczęły się spłaszczać. Zwiększenie rozmiaru wąskiego gardła jedynie w pewnym stopniu złagodzi ten problem, ale nie rozwiąże go całkowicie.
Częściowo wynika to z zastosowanej w tym przypadku funkcji straty, czyli błędu średniokwadratowego, która nie radzi sobie zbyt dobrze przy pomiarze strat w modelach generatywnych. W większości te rozmyte rekonstrukcje są zmorą zadań autoenkoderów splotowych. Jeśli celem jest rekonstrukcja lub generowanie obrazów, bezpieczniejszym rozwiązaniem może być generatywna sieć kontradyktoryjna (GAN) lub model dyfuzyjny. Nie oznacza to jednak, że autoenkodery splotowe nie są przydatne, ponieważ można ich używać do wykrywania anomalii, usuwania szumów obrazu i tak dalej.
Uwagi końcowe
W tym artykule omówiliśmy autoenkodery w kontekście danych obrazowych. Następnie przyjrzeliśmy się, co dokładnie robi splotowy autokoder i jak to robi, mając na celu rozwinięcie intuicji dotyczącej jego zasady działania. Następnie poruszyliśmy inną sekcję, zanim przejdziemy dalej, aby zdefiniować własny niestandardowy autoenkoder, trenować go i omawiać wyniki uczenia modelu.








