Wykonaj dla mnie kody w języku python, których będę mógł użyć do szkolenia moich modeli…
- User
Wykonaj dla mnie kody w języku python, których będę mógł użyć do szkolenia moich modeli dla moich zbiorów danych: Zadanie to wynaj na podstawie tego artykułu: \documentclass{article} \usepackage[utf8]{inputenc} \usepackage[T1]{fontenc} \usepackage[polish]{babel} \usepackage{lmodern} \usepackage{amsmath, amssymb} \usepackage{geometry} \usepackage{graphicx} \usepackage{float} \usepackage{listings} \usepackage{xcolor} \usepackage{hyperref} \usepackage{caption} \usepackage{mathtools} \usepackage{bm} \usepackage{enumitem} \usepackage{csquotes} \usepackage{booktabs} \usepackage{multirow}
\geometry{margin=1in}
\lstdefinestyle{pythonstyle}{ language=Python, basicstyle=\ttfamily\small, keywordstyle=\color{blue}, stringstyle=\color{red}, commentstyle=\color{olive}\itshape, morecomment=[l][\color{magenta}]{#}, numbers=left, numberstyle=\tiny\color{gray}, stepnumber=1, numbersep=5pt, showspaces=false, showstringspaces=false, frame=single, captionpos=b, breaklines=true, breakatwhitespace=true, tabsize=4, literate= {ą}{{\k{a}}}1 {Ą}{{\k{A}}}1 {ć}{{'c}}1 {Ć}{{'C}}1 {ę}{{\k{e}}}1 {Ę}{{\k{E}}}1 {ł}{{\l{}}}1 {Ł}{{\L{}}}1 {ń}{{'n}}1 {Ń}{{'N}}1 {ó}{{'o}}1 {Ó}{{'O}}1 {ś}{{'s}}1 {Ś}{{'S}}1 {ż}{{.z}}1 {Ż}{{.Z}}1 {ź}{{'z}}1 {Ź}{{'Z}}1 } \lstset{style=pythonstyle}
\begin{document}
\title{\textbf{Rozszerzenie \emph{Variational Autoencoder (VAE)} do generowania bardziej złożonych danych}} \author{Mateusz Kacpura} \date{\today}
\maketitle
\begin{abstract} Celem niniejszej pracy jest rozwinięcie wcześniej zbudowanego modelu \emph{Variational Autoencoder} (VAE) w celu lepszego uchwycenia i generowania bardziej złożonych danych. Dokonano tego poprzez modyfikację architektury modelu, eksperymenty z różnymi parametrami oraz analizę wpływu tych zmian na jakość generowanych danych. Przeprowadzono także interpolacje w przestrzeni latentnej oraz wizualizację przestrzeni latentnej przy użyciu technik redukcji wymiarów. \end{abstract}
\tableofcontents \newpage
\section{Wstęp}
\subsection{Motywacja}
Modele generatywne, takie jak \emph{Variational Autoencoder} (VAE), odgrywają kluczową rolę w dziedzinie uczenia maszynowego, umożliwiając modelowanie skomplikowanych rozkładów danych \cite{Kingma2014}. Dotychczasowe modele VAE były stosowane głównie do prostych zbiorów danych, takich jak MNIST, co ograniczało ich zdolność do generowania bardziej złożonych struktur.
\subsection{Cel pracy}
Celem pracy jest rozwinięcie wcześniejszego modelu VAE tak, aby lepiej uchwycić i generować bardziej złożone dane. W ramach pracy:
\begin{enumerate}[noitemsep,nolistsep] \item \textbf{Opis wcześniejszego modelu VAE} Prezentacja gęstych warstw i wcześniejszego kodu
\item \textbf{Wybór nowego zbioru danych}: Rozszerzenie modelu na bardziej złożone zbiory danych, takie jak \textbf{Fashion MNIST}, \textbf{CIFAR-10}, \textbf{CIFAR-100} oraz \textbf{CelebA}. \item \textbf{Zmiana architektury modelu}: \begin{itemize}[noitemsep,nolistsep] \item Wprowadzenie \emph{konwolucyjnych VAE} poprzez dodanie warstw konwolucyjnych do enkodera i dekodera. \item Pogłębienie sieci przez dodanie większej liczby warstw i jednostek ukrytych. \item Eksperymenty z różnymi wymiarami przestrzeni latentnej $z$. \end{itemize} \item \textbf{Eksperymenty z funkcją straty}: \begin{itemize}[noitemsep,nolistsep] \item Analiza wpływu zmiany wagi komponentu dywergencji Kullbacka-Leiblera (KL) na balans między rekonstrukcją a regularnością przestrzeni latentnej. \item Dodanie dodatkowego termu w funkcji straty, kładącego większy nacisk na rekonstrukcję detali. \end{itemize} \item \textbf{Interpolacje w przestrzeni latentnej}: Wygenerowanie próbek obrazów, które są interpolacją pomiędzy dwoma punktami w przestrzeni latentnej, aby obserwować przejścia między obiektami. \item \textbf{Wizualizacja przestrzeni latentnej}: Redukcja wymiarów przestrzeni latentnej do 2D za pomocą metod takich jak PCA lub t-SNE, w celu zobaczenia, jak VAE rozdziela różne klasy obiektów.\end{enumerate}
\newpage
\section{Wcześniejszy model VAE}
\subsection{Opis modelu}
Pierwotny model VAE został zbudowany i przetestowany na zbiorze danych MNIST \cite{LeCun1998}, zawierającym ręcznie pisane cyfry. Model wykorzystywał jedynie warstwy gęste (\textit{Dense Layers}) w enkoderze i dekoderze.
\subsection{Implementacja}
\begin{lstlisting}[caption=Implementacja podstawowego VAE na zbiorze MNIST, label=code:basic_vae] import numpy as np import tensorflow as tf from tensorflow.keras.datasets import mnist from tensorflow.keras.layers import Layer, Dense from tensorflow.keras.models import Sequential, Model
1. Załadowanie i przygotowanie danych MNIST
(x_train, _), (x_test, _) = mnist.load_data() x_train = x_train.astype('float32') / 255. x_test = x_test.astype('float32') / 255. x_train_d = np.reshape(x_train, (x_train.shape[0], -1)) x_test_d = np.reshape(x_test, (x_test.shape[0], -1))
2. Definicja warstwy enkodera
class Encoder(Layer): def init(self, architecture): super(Encoder, self).init() self.model = Sequential([Dense(ni, activation='relu') for ni in architecture])
def call(self, x): return self.model(x)3. Definicja warstwy dekodera
class Decoder(Layer): def init(self, architecture, original_dim): super(Decoder, self).init() layers = [Dense(ni, activation='relu') for ni in architecture] layers.append(Dense(original_dim, activation='sigmoid')) self.model = Sequential(layers)
def call(self, x): return self.model(x)4. Definicja modelu Autoenkodera
class Autoencoder(Model): def init(self, encoder_architecture, decoder_architecture, original_dim): super(Autoencoder, self).init() self.encoder = Encoder(encoder_architecture) self.decoder = Decoder(decoder_architecture, original_dim)
def call(self, x): z = self.encoder(x) y = self.decoder(z) return y5. Inicjalizacja Autoenkodera
original_dim = x_train_d.shape[1] # 784 autoencoder = Autoencoder(encoder_architecture=[64, 32, 16], decoder_architecture=[16, 32, 64], original_dim=original_dim)
6. Kompilacja modelu
autoencoder.compile(optimizer='adam', loss='mse', metrics=['mse'])
7. Trening Autoenkodera przy użyciu model.fit
history = autoencoder.fit(x_train_d, x_train_d, epochs=20, batch_size=256, shuffle=True, validation_data=(x_test_d, x_test_d))
8. Rekonstrukcja obrazów testowych
x_test_reconstructed = autoencoder.predict(x_test_d)
9. Wyświetlenie oryginalnych i zrekonstruowanych obrazów
def plot_reconstructions(x_original, x_reconstructed, num_images=10): plt.figure(figsize=(20, 4)) for i in range(num_images): # Wyświetlenie oryginalnych obrazów ax = plt.subplot(2, num_images, i + 1) plt.imshow(x_original[i], cmap='gray') ax.axis('off')
# Wyświetlenie zrekonstruowanych obrazów ax = plt.subplot(2, num_images, i + 1 + num_images) plt.imshow(x_reconstructed[i].reshape(28, 28), cmap='gray') ax.axis('off') plt.tight_layout() plt.show()plot_reconstructions(x_test, x_test_reconstructed, num_images=10) \end{lstlisting}
\subsection{Ograniczenia modelu}
Model ten sprawdza się dobrze dla prostych danych, takich jak ręcznie pisane cyfry z MNIST. Jednak jego możliwości są ograniczone w przypadku bardziej złożonych danych ze względu na:
\begin{itemize}[noitemsep,nolistsep] \item Brak warstw konwolucyjnych, co utrudnia uchwycenie lokalnych wzorców w danych obrazowych. \item Ograniczoną głębokość sieci, co wpływa na zdolność modelu do reprezentowania skomplikowanych zależności. \item Statyczną architekturę, która nie pozwala na łatwą adaptację do różnorodnych zbiorów danych. \end{itemize}
\newpage
\section{Rozwinięcie modelu VAE}
\subsection{Wybór nowego zbioru danych}
Aby zwiększyć złożoność zadania i przetestować zdolności modelu, wybrano trzy zbiory danych:
\begin{enumerate}[noitemsep,nolistsep] \item \textbf{Fashion MNIST} \cite{Xiao2017}: Zbiór zawierający obrazy ubrań, który jest bardziej złożony niż cyfry z MNIST.
\item \textbf{CIFAR-10} \cite{Krizhevsky2009}: Zawierający kolorowe obrazy 32x32 pikseli z 10 klasami obiektów, takimi jak samochody, ptaki czy koty. \item \textbf{CelebA} \cite{Liu2015}: Duży zbiór danych zawierający ponad 200 tysięcy obrazów twarzy z różnymi atrybutami, pozwalający na badanie jakości generowania realistycznych obrazów ludzi oraz manipulacji cechami twarzy w przestrzeni latentnej.\end{enumerate}
\subsubsection{Przygotowanie danych}
\paragraph{Fashion MNIST} Dane są już w formacie 28x28 w skali szarości, więc wymagają minimalnej obróbki.
\begin{lstlisting}[language=Python, caption=Ładowanie zbioru Fashion MNIST, label=code:fashion_mnist] from tensorflow.keras.datasets import fashion_mnist
Załadowanie danych
(x_train_fashion, _), (x_test_fashion, _) = fashion_mnist.load_data()
Normalizacja i zmiana kształtu
x_train_fashion = x_train_fashion.astype('float32') / 255. x_test_fashion = x_test_fashion.astype('float32') / 255. x_train_fashion = np.expand_dims(x_train_fashion, -1) x_test_fashion = np.expand_dims(x_test_fashion, -1) \end{lstlisting}
\paragraph{CIFAR-10} Dane wymagają skalowania i ewentualnie zmiany rozmiaru obrazów, jeśli model nie obsługuje danych o takim rozmiarze.
\begin{lstlisting}[language=Python, caption=Ładowanie zbioru CIFAR-10, label=code:cifar10] from tensorflow.keras.datasets import cifar10
Załadowanie danych
(x_train_cifar, _), (x_test_cifar, _) = cifar10.load_data()
Normalizacja
x_train_cifar = x_train_cifar.astype('float32') / 255. x_test_cifar = x_test_cifar.astype('float32') / 255. \end{lstlisting}
\paragraph{CelebA} Stanowią obszerny zbiór obrazów twarzy celebrytów, wykorzystywany szeroko w zadaniach z zakresu uczenia maszynowego, w tym w trenowaniu Wariacyjnych Autoenkoderów (VAE). W celu efektywnego wykorzystania tych danych w procesie trenowania modelu VAE, niezbędne jest ich odpowiednie wczytanie i przetworzenie.
\paragraph{Montaż Dysku Google w środowisku Google Colab} Pierwszym krokiem jest zapewnienie dostępu do zbioru danych przechowywanego na Dysku Google. W środowisku Google Colab możliwe jest zamontowanie własnego dysku:
\begin{lstlisting}[language=Python, caption=Montaż Dysku Google w Colab, label=code:mount_drive] from google.colab import drive drive.mount('/content/drive') \end{lstlisting}
Proces wymagał autoryzacji dostępu do Dysku Google, co zostało zainicjowane po wykonaniu powyższego kodu.
\paragraph{Lokalizacja i struktura danych CelebA}
Zakładając, że zbiór danych CelebA znajduje się w folderze:
\begin{verbatim} /content/drive/MyDrive/archiwum/BAK-programowanie/CelebA-Dialog (HQ)/ \end{verbatim}
Folder ten zawiera następujące pliki i katalogi:
\begin{itemize} \item \texttt{CelebA-HQ-to-CelebA-mapping.txt} \item \texttt{classification_label/} \item \texttt{identity/} \item \texttt{image.zip} \item \texttt{mask/} \item \texttt{text/} \end{itemize}
\paragraph{Rozpakowanie zbioru obrazów}
Zbiór obrazów jest zapisany w skompresowanym archiwum \texttt{image.zip}. Aby móc wczytać obrazy, należy rozpakować archiwum:
\begin{lstlisting}[language=Python, caption=Rozpakowanie archiwum z obrazami, label=code:unzip_images]
Ścieżki
dataset_path = '/content/drive/MyDrive/archiwum/BAK-programowanie/CelebA-Dialog (HQ)' zip_path = os.path.join(dataset_path, 'image.zip') local_extract_path = '/content/images'
Rozpakowanie archiwum
if not os.path.exists(local_extract_path): os.makedirs(local_extract_path) print(f"Rozpakowywanie pliku ZIP: {zip_path} do {local_extract_path}...") with zipfile.ZipFile(zip_path, 'r') as zip_ref: zip_ref.extractall(local_extract_path) print("Rozpakowywanie zakończone!")
\end{lstlisting}
\paragraph{Wczytanie ścieżek do obrazów}
Po rozpakowaniu archiwum, obrazy znajdują się w folderze \texttt{image}. Możemy wczytać wszystkie ścieżki do plików graficznych za pomocą modułu \texttt{glob}:
\begin{lstlisting}[language=Python, caption=Wczytanie ścieżek do obrazów, label=code:load_image_paths] local_extract_path = '/content/images/image'
Wczytanie wszystkich ścieżek obrazów z rozszerzeniem .jpg
image_paths = glob.glob(os.path.join(local_extract_path, '*.jpg')) print(f'Liczba wczytanych obrazów: {len(image_paths)}')
Wyświetlenie 5 przykładowych obrazów
for i in range(min(5, len(image_paths))): image = Image.open(image_paths[i]) # Załaduj obraz plt.imshow(image) plt.axis('off') plt.show() \end{lstlisting}
\newpage
\subsection{Zmiana architektury modelu}
\subsubsection{Konwolucyjne VAE}
Aby lepiej uchwycić lokalne wzorce w danych obrazowych, wprowadzono warstwy konwolucyjne do enkodera i dekodera.
\begin{lstlisting}[caption=Definicja konwolucyjnego enkodera, label=code:conv_encoder] def build_conv_encoder(input_shape, latent_dim): inputs = Input(shape=input_shape) x = Conv2D(32, kernel_size=3, strides=2, activation='relu', padding='same')(inputs) x = Conv2D(64, kernel_size=3, strides=2, activation='relu', padding='same')(x) x = Conv2D(128, kernel_size=3, strides=2, activation='relu', padding='same')(x) x = Flatten()(x) x = Dense(256, activation='relu')(x) z_mean = Dense(latent_dim, name='z_mean')(x) z_log_var = Dense(latent_dim, name='z_log_var')(x) z = Sampling()([z_mean, z_log_var]) return Model(inputs, [z_mean, z_log_var, z], name='encoder') \end{lstlisting}
\begin{lstlisting}[caption=Definicja konwolucyjnego dekodera, label=code:conv_decoder] def build_conv_decoder(output_shape, latent_dim): latent_inputs = Input(shape=(latent_dim,)) x = Dense(4 * 4 * 128, activation='relu')(latent_inputs) x = Reshape((4, 4, 128))(x) x = Conv2DTranspose(128, kernel_size=3, strides=2, activation='relu', padding='same')(x) x = Conv2DTranspose(64, kernel_size=3, strides=2, activation='relu', padding='same')(x) x = Conv2DTranspose(32, kernel_size=3, strides=2, activation='relu', padding='same')(x) x = Conv2DTranspose(output_shape[-1], kernel_size=3, strides=1, activation='sigmoid', padding='same')(x) return Model(latent_inputs, x, name='decoder') \end{lstlisting}
\subsubsection{Głębsza sieć}
Dodano większą liczbę warstw i jednostek ukrytych w obu sieciach, co pozwala modelowi uczyć się bardziej złożonych reprezentacji.
\subsubsection{Eksperymenty z wymiarem przestrzeni latentnej }
Przeprowadzono eksperymenty z wymiarami , aby zbadać wpływ rozmiaru przestrzeni latentnej na jakość generacji.
\newpage
\subsection{Eksperymenty z funkcją straty}
\subsubsection{Wpływ wagi dywergencji KL}
Funkcja straty w VAE składa się z dwóch komponentów: straty rekonstrukcji i dywergencji KL. Kontrolując wagę komponentu dywergencji KL, wpływamy na balans między jakością rekonstrukcji a regularnością przestrzeni latentnej.
\begin{lstlisting}[caption=Modyfikacja wagi dywergencji KL w klasie VAE, label=code:kl_weight] class VAE(Model): def init(self, encoder, decoder, kl_weight=1.0, **kwargs): super(VAE, self).init(**kwargs) self.encoder = encoder self.decoder = decoder self.kl_weight = kl_weight # Reszta kodu pozostaje bez zmian \end{lstlisting}
Przeprowadzono eksperymenty z \texttt{kl_weight} .
\subsubsection{Dodatkowy term w funkcji straty}
Aby zwiększyć nacisk na rekonstrukcję detali, dodano dodatkowy term w funkcji straty, taki jak \emph{Structural Similarity Index Measure} (SSIM) lub \emph{Perceptual Loss}.
\begin{lstlisting}[caption=Dodanie SSIM do funkcji straty, label=code:ssim_loss] def compute_loss(model, x): z_mean, z_log_var, z = model.encoder(x) x_recon = model.decoder(z) # Binary crossentropy loss recon_loss = tf.reduce_mean( tf.reduce_sum( tf.keras.losses.binary_crossentropy(x, x_recon), axis=[1, 2, 3] ) ) # SSIM loss ssim_loss = 1 - tf.reduce_mean(tf.image.ssim(x, x_recon, max_val=1.0)) # KL divergence kl_loss = -0.5 * tf.reduce_sum(1 + z_log_var - tf.square(z_mean) - tf.exp(z_log_var), axis=1) kl_loss = tf.reduce_mean(kl_loss) total_loss = recon_loss + model.kl_weight * kl_loss + ssim_loss return total_loss \end{lstlisting}
\subsection{Interpolacje w przestrzeni latentnej}
Interpolacje w przestrzeni latentnej pozwalają na obserwację płynnych przejść między różnymi obiektami.
\begin{lstlisting}[caption=Wykonanie interpolacji między dwoma obrazami, label=code:interpolation] def interpolate_images(model, img1, img2, num_steps=10): z_mean1, _, _ = model.encoder.predict(img1) z_mean2, _, _ = model.encoder.predict(img2) interpolations = [] for alpha in np.linspace(0, 1, num_steps): z = (1 - alpha) * z_mean1 + alpha * z_mean2 img_recon = model.decoder.predict(z) interpolations.append(img_recon) return interpolations \end{lstlisting}
\subsection{Wizualizacja przestrzeni latentnej}
Aby zobaczyć, jak różne klasy obiektów są reprezentowane w przestrzeni latentnej, zastosowano algorytmy redukcji wymiarów, takie jak t-SNE.
\begin{lstlisting}[caption=Redukcja wymiarów przestrzeni latentnej, label=code:tsne_visualization] from sklearn.manifold import TSNE
Zakodowanie danych testowych
z_means, _, _ = model.encoder.predict(x_test)
Redukcja wymiarów do 2D
tsne = TSNE(n_components=2) z_2d = tsne.fit_transform(z_means)
Wizualizacja
plt.scatter(z_2d[:, 0], z_2d[:, 1], c=y_test, cmap='tab10') plt.colorbar() plt.xlabel('Wymiar 1') plt.ylabel('Wymiar 2') plt.title('Wizualizacja przestrzeni latentnej') plt.show() \end{lstlisting}
\newpage
\section{Eksperymenty i wyniki}
\subsection{Wyniki dla różnych zbiorów danych}
Przeprowadzono trening modelu na wybranych zbiorach danych, analizując jakość rekonstrukcji oraz zdolności generacyjne.
\subsubsection{Fashion MNIST}
Model osiągnął dobrą jakość rekonstrukcji, zachowując detale ubrań. Interpolacje między różnymi klasami (np. but a koszulka) pokazały płynne przejścia.
\begin{figure}[H] \centering \includegraphics[width=\textwidth]{fashion_mnist_reconstructions.png} \caption{Porównanie oryginalnych i zrekonstruowanych obrazów Fashion MNIST. Górny rząd: oryginały; dolny rząd: rekonstrukcje.} \label{fig:fashion_mnist_reconstructions} \end{figure}
\subsubsection{CIFAR-10}
Ze względu na większą złożoność i kolorystykę danych, model wymagał głębszej architektury i większego wymiaru przestrzeni latentnej. Rekonstrukcje były akceptowalne, jednak jakościowo gorsze niż dla Fashion MNIST.
\begin{figure}[H] \centering \includegraphics[width=\textwidth]{cifar10_reconstructions.png} \caption{Porównanie oryginalnych i zrekonstruowanych obrazów CIFAR-10. Górny rząd: oryginały; dolny rząd: rekonstrukcje.} \label{fig:cifar10_reconstructions} \end{figure}
\subsubsection{CelebA}
Model był w stanie generować realistyczne twarze, a manipulacje w przestrzeni latentnej pozwoliły na zmianę atrybutów, takich jak uśmiech czy noszenie okularów.
\begin{figure}[H] \centering \includegraphics[width=\textwidth]{celeba_reconstructions.png} \caption{Porównanie oryginalnych i zrekonstruowanych obrazów CelebA. Górny rząd: oryginały; dolny rząd: rekonstrukcje.} \label{fig:celeba_reconstructions} \end{figure}
\subsection{Wpływ parametrów modelu}
\subsubsection{Wymiar przestrzeni latentnej}
Zwiększenie wymiaru poprawiało jakość rekonstrukcji, ale po przekroczeniu pewnej wartości efekt był marginalny, a czas treningu znacząco się wydłużał. Tabela \ref{tab:latent_dim} przedstawia wpływ wymiaru latentnego na stratę rekonstrukcji.
\begin{table}[H] \centering \begin{tabular}{c c} \toprule Wymiar latentny & Strata rekonstrukcji \ \midrule 2 & 0.125 \ 8 & 0.098 \ 16 & 0.085 \ 32 & 0.082 \ 64 & 0.081 \ \bottomrule \end{tabular} \caption{Wpływ wymiaru latentnego na stratę rekonstrukcji dla zbioru Fashion MNIST.} \label{tab:latent_dim} \end{table}
\subsubsection{Waga dywergencji KL}
Zmniejszenie wagi dywergencji KL prowadziło do lepszych rekonstrukcji, ale kosztem regularności przestrzeni latentnej, co objawiało się problemami przy generowaniu nowych próbek i interpolacjach.
\begin{figure}[H] \centering \includegraphics[width=\textwidth]{kl_weight_effect.png} \caption{Wpływ wagi dywergencji KL na stratę rekonstrukcji i stratę KL.} \label{fig:kl_weight_effect} \end{figure}
\subsection{Interpolacje i wizualizacja przestrzeni latentnej}
Interpolacje pokazały, że model dobrze uczy się reprezentacji danych, a przejścia między różnymi klasami są płynne i logiczne.
\begin{figure}[H] \centering \includegraphics[width=\textwidth]{latent_space_interpolations.png} \caption{Interpolacje między obrazami w przestrzeni latentnej dla zbioru Fashion MNIST.} \label{fig:latent_space_interpolations} \end{figure}
Wizualizacja przestrzeni latentnej ujawniła, że model grupuje podobne klasy obiektów blisko siebie.
\begin{figure}[H] \centering \includegraphics[width=0.8\textwidth]{latent_space_visualization.png} \caption{Wizualizacja przestrzeni latentnej przy użyciu t-SNE dla zbioru Fashion MNIST.} \label{fig:latent_space_visualization} \end{figure}
\section{Wnioski}
Przeprowadzone eksperymenty wykazały, że rozszerzenie modelu VAE poprzez zastosowanie warstw konwolucyjnych, pogłębienie sieci oraz dostosowanie parametrów, takich jak wymiar przestrzeni latentnej i waga dywergencji KL, pozwala na skuteczne modelowanie i generowanie bardziej złożonych danych. Odpowiedni wybór architektury i parametrów jest kluczowy dla uzyskania wysokiej jakości wyników.
\end{document}
- Assistant
Oczywiście, poniżej znajdziesz kompletny zestaw kodów w języku Python, który umożliwi Ci trenowanie modeli Variational Autoencoder (VAE) na różnych zbiorach danych, takich jak MNIST, Fashion MNIST, CIFAR-10 oraz CelebA. Kod jest podzielony na kilka sekcji, odpowiadających poszczególnym etapom opisywanym w artykule. Każda sekcja zawiera niezbędne wyjaśnienia oraz fragmenty kodu, które możesz dostosować do swoich potrzeb.
Spis Treści
- Wymagania
- Importowanie Bibliotek
- Przygotowanie Danych
- Definicja Warstwy Sampling
- Definicja Modelu VAE
- Trenowanie Modelu
- Interpolacje w Przestrzeni Latentnej
- Wizualizacja Przestrzeni Latentnej
- Przykładowe Funkcje Pomocnicze
1. Wymagania
Upewnij się, że posiadasz zainstalowane poniższe biblioteki. Możesz je zainstalować za pomocą
pip, jeśli jeszcze ich nie masz.pip install tensorflow numpy matplotlib scikit-learn pillow opencv-python2. Importowanie Bibliotek
import os import zipfile import glob import numpy as np import matplotlib.pyplot as plt from PIL import Image import tensorflow as tf from tensorflow.keras import layers, Model, Input from tensorflow.keras.layers import Dense, Conv2D, Conv2DTranspose, Flatten, Reshape, Lambda from tensorflow.keras.models import Sequential from tensorflow.keras.losses import binary_crossentropy from sklearn.manifold import TSNE import cv2 # Do przetwarzania obrazów CelebA3. Przygotowanie Danych
MNIST
from tensorflow.keras.datasets import mnist # Załadowanie danych MNIST (x_train_mnist, _), (x_test_mnist, _) = mnist.load_data() x_train_mnist = x_train_mnist.astype('float32') / 255. x_test_mnist = x_test_mnist.astype('float32') / 255. x_train_mnist = np.expand_dims(x_train_mnist, -1) # Dodanie kanału x_test_mnist = np.expand_dims(x_test_mnist, -1)Fashion MNIST
from tensorflow.keras.datasets import fashion_mnist # Załadowanie danych Fashion MNIST (x_train_fashion, _), (x_test_fashion, _) = fashion_mnist.load_data() x_train_fashion = x_train_fashion.astype('float32') / 255. x_test_fashion = x_test_fashion.astype('float32') / 255. x_train_fashion = np.expand_dims(x_train_fashion, -1) x_test_fashion = np.expand_dims(x_test_fashion, -1)CIFAR-10
from tensorflow.keras.datasets import cifar10 # Załadowanie danych CIFAR-10 (x_train_cifar, _), (x_test_cifar, _) = cifar10.load_data() x_train_cifar = x_train_cifar.astype('float32') / 255. x_test_cifar = x_test_cifar.astype('float32') / 255.CelebA
Uwaga: Zbiór danych CelebA jest obszerny i często wymaga specjalnej uwagi w zakresie przetwarzania. Poniżej znajduje się przykładowy kod do załadowania i przygotowania danych CelebA z lokalnego dysku. Zakłada on, że masz już pobrany i rozpakowany zestaw danych CelebA.
import glob from tensorflow.keras.preprocessing.image import load_img, img_to_array # Ścieżka do folderu z obrazami CelebA celeba_path = '/path/to/celeba/images/' # Zmień na właściwą ścieżkę def load_celeba_images(path, img_size=(64, 64)): image_paths = glob.glob(os.path.join(path, '*.jpg')) images = [] for img_path in image_paths: img = load_img(img_path, target_size=img_size) img = img_to_array(img) / 255. images.append(img) return np.array(images) # Ładowanie danych CelebA x_train_celeba = load_celeba_images(celeba_path)Uwagi:
- Wymiar Obrazów: Upewnij się, że wszystkie obrazy mają ten sam rozmiar. W powyższym przykładzie ustawiono
img_sizena(64, 64). - Memory Management: Zbiór CelebA jest duży, więc warto rozważyć użycie generatorów lub przetwarzanie danych partiami, jeśli pamięć RAM jest ograniczona.
4. Definicja Warstwy Sampling
Warstwa ta jest kluczowa dla modelu VAE, umożliwiając próbkowanie z rozkładu latentnego.
class Sampling(layers.Layer): def call(self, inputs): z_mean, z_log_var = inputs batch = tf.shape(z_mean)[0] dim = tf.shape(z_mean)[1] epsilon = tf.keras.backend.random_normal(shape=(batch, dim)) return z_mean + tf.exp(0.5 * z_log_var) * epsilon5. Definicja Modelu VAE
Konwolucyjny Enkoder
def build_conv_encoder(input_shape, latent_dim): encoder_inputs = Input(shape=input_shape) x = Conv2D(32, kernel_size=3, strides=2, activation='relu', padding='same')(encoder_inputs) x = Conv2D(64, kernel_size=3, strides=2, activation='relu', padding='same')(x) x = Conv2D(128, kernel_size=3, strides=2, activation='relu', padding='same')(x) x = Flatten()(x) x = Dense(256, activation='relu')(x) z_mean = Dense(latent_dim, name='z_mean')(x) z_log_var = Dense(latent_dim, name='z_log_var')(x) z = Sampling()([z_mean, z_log_var]) encoder = Model(encoder_inputs, [z_mean, z_log_var, z], name='encoder') encoder.summary() return encoderKonwolucyjny Dekoder
def build_conv_decoder(output_shape, latent_dim): decoder_inputs = Input(shape=(latent_dim,)) x = Dense(4 * 4 * 128, activation='relu')(decoder_inputs) x = Reshape((4, 4, 128))(x) x = Conv2DTranspose(128, kernel_size=3, strides=2, activation='relu', padding='same')(x) # 8x8 x = Conv2DTranspose(64, kernel_size=3, strides=2, activation='relu', padding='same')(x) # 16x16 x = Conv2DTranspose(32, kernel_size=3, strides=2, activation='relu', padding='same')(x) # 32x32 x = Conv2DTranspose(output_shape[-1], kernel_size=3, strides=1, activation='sigmoid', padding='same')(x) decoder = Model(decoder_inputs, x, name='decoder') decoder.summary() return decoderKlasa VAE z Modyfikowaną Funkcją Straty
class VAE(Model): def __init__(self, encoder, decoder, kl_weight=1.0, **kwargs): super(VAE, self).__init__(**kwargs) self.encoder = encoder self.decoder = decoder self.kl_weight = kl_weight def compile(self, optimizer, loss_fn): super(VAE, self).compile() self.optimizer = optimizer self.loss_fn = loss_fn def train_step(self, data): if isinstance(data, tuple): data = data[0] with tf.GradientTape() as tape: z_mean, z_log_var, z = self.encoder(data) reconstruction = self.decoder(z) # Rekonstrukcja straty reconstruction_loss = tf.reduce_mean( tf.reduce_sum( binary_crossentropy(data, reconstruction), axis=[1, 2, 3] ) ) # Dywergencja KL kl_loss = -0.5 * tf.reduce_mean( tf.reduce_sum(1 + z_log_var - tf.square(z_mean) - tf.exp(z_log_var), axis=1) ) # Całkowita strata total_loss = reconstruction_loss + self.kl_weight * kl_loss grads = tape.gradient(total_loss, self.trainable_weights) self.optimizer.apply_gradients(zip(grads, self.trainable_weights)) return {"loss": total_loss, "reconstruction_loss": reconstruction_loss, "kl_loss": kl_loss}Uwagi:
- Kl_weight: Parametr
kl_weightpozwala na ważenie składnika dywergencji KL w funkcji straty. Dzięki temu możesz kontrolować balans między jakością rekonstrukcji a regularnością przestrzeni latentnej. - Funkcja Straty: Możesz modyfikować funkcję straty, dodając dodatkowe składniki, takie jak SSIM czy Perceptual Loss, jeśli chcesz zwiększyć nacisk na detale rekonstrukcji.
6. Trenowanie Modelu
Poniżej znajduje się przykładowy kod do trenowania modelu VAE na zbiorze Fashion MNIST. Możesz dostosować go do innych zbiorów danych, zmieniając
input_shapeoraz ścieżki do danych.# Parametry latent_dim = 16 input_shape = (28, 28, 1) # Dla Fashion MNIST batch_size = 128 epochs = 30 # Budowa Enkodera i Dekodera encoder = build_conv_encoder(input_shape, latent_dim) decoder = build_conv_decoder(input_shape, latent_dim) # Inicjalizacja VAE vae = VAE(encoder, decoder, kl_weight=1.0) vae.compile(optimizer=tf.keras.optimizers.Adam(), loss_fn='mse') # Przygotowanie danych (x_train, _), (x_test, _) = fashion_mnist.load_data() x_train = x_train.astype('float32') / 255. x_test = x_test.astype('float32') / 255. x_train = np.expand_dims(x_train, -1) x_test = np.expand_dims(x_test, -1) # Trenowanie history = vae.fit(x_train, epochs=epochs, batch_size=batch_size, validation_data=(x_test, None))Przykład dla CIFAR-10:
# Parametry dla CIFAR-10 latent_dim = 32 input_shape = (32, 32, 3) # Dla CIFAR-10 batch_size = 256 epochs = 50 # Budowa Enkodera i Dekodera encoder = build_conv_encoder(input_shape, latent_dim) decoder = build_conv_decoder(input_shape, latent_dim) # Inicjalizacja VAE vae = VAE(encoder, decoder, kl_weight=1.0) vae.compile(optimizer=tf.keras.optimizers.Adam(), loss_fn='mse') # Przygotowanie danych (x_train, _), (x_test, _) = cifar10.load_data() x_train = x_train.astype('float32') / 255. x_test = x_test.astype('float32') / 255. # Trenowanie history = vae.fit(x_train, epochs=epochs, batch_size=batch_size, validation_data=(x_test, None))Przykład dla CelebA:
# Parametry dla CelebA latent_dim = 64 input_shape = (64, 64, 3) # Jeśli używasz 64x64 pikseli batch_size = 128 epochs = 100 # Budowa Enkodera i Dekodera encoder = build_conv_encoder(input_shape, latent_dim) decoder = build_conv_decoder(input_shape, latent_dim) # Inicjalizacja VAE vae = VAE(encoder, decoder, kl_weight=1.0) vae.compile(optimizer=tf.keras.optimizers.Adam(), loss_fn='mse') # Przygotowanie danych # Zakładamy, że dane CelebA zostały załadowane do x_train_celeba # Możesz również podzielić dane na walidacyjne, jeśli to konieczne # Trenowanie history = vae.fit(x_train_celeba, epochs=epochs, batch_size=batch_size, validation_split=0.1)7. Interpolacje w Przestrzeni Latentnej
Interpolacje pozwalają na generowanie płynnych przejść między dwoma punktami w przestrzeni latentnej, co ilustruje zdolność modelu do generowania spójnych danych.
def interpolate_vectors(model, img1, img2, num_steps=10): # Zakodowanie obrazów do przestrzeni latentnej z_mean1, _, _ = model.encoder.predict(np.expand_dims(img1, axis=0)) z_mean2, _, _ = model.encoder.predict(np.expand_dims(img2, axis=0)) # Generowanie interpolacji interpolated_images = [] for alpha in np.linspace(0, 1, num_steps): z = (1 - alpha) * z_mean1 + alpha * z_mean2 reconstructed = model.decoder.predict(z) interpolated_images.append(reconstructed[0]) return interpolated_images # Przykład użycia import random # Wybór losowych obrazów z testowego zestawu danych Fashion MNIST idx1, idx2 = random.sample(range(x_test_fashion.shape[0]), 2) img1 = x_test_fashion[idx1] img2 = x_test_fashion[idx2] # Generowanie interpolacji interpolations = interpolate_vectors(vae, img1, img2, num_steps=10) # Wyświetlanie wyników plt.figure(figsize=(20, 4)) for i, img in enumerate(interpolations): ax = plt.subplot(1, 10, i + 1) plt.imshow(img.squeeze(), cmap='gray') plt.axis('off') plt.show()8. Wizualizacja Przestrzeni Latentnej
Redukcja wymiarów przestrzeni latentnej do 2D za pomocą t-SNE pozwala na wizualizację, jak różne klasy danych są rozmieszczone w przestrzeni latentnej.
# Zakodowanie danych testowych z_mean, _, _ = vae.encoder.predict(x_test_fashion) # Redukcja wymiarów do 2D za pomocą t-SNE tsne = TSNE(n_components=2, random_state=42) z_2d = tsne.fit_transform(z_mean) # Jeśli masz etykiety klas, możesz je użyć do kolorowania punktów # Zakładamy, że masz zmienną y_test_fashion z etykietami (_, (x_test_fashion, y_test_fashion)) = fashion_mnist.load_data() y_test_fashion = y_test_fashion.astype('int') plt.figure(figsize=(10, 8)) scatter = plt.scatter(z_2d[:, 0], z_2d[:, 1], c=y_test_fashion, cmap='tab10', alpha=0.5) plt.colorbar(scatter, ticks=range(10)) plt.xlabel('Wymiar 1') plt.ylabel('Wymiar 2') plt.title('Wizualizacja przestrzeni latentnej za pomocą t-SNE') plt.show()Uwagi:
- Etykiety Klas: Aby kolorować punkty zgodnie z klasami, potrzebujesz etykiet. W powyższym przykładzie założono, że masz
y_test_fashion. Jeśli korzystasz z innych zbiorów danych, dostosuj tę część kodu odpowiednio. - Parametry t-SNE: Możesz eksperymentować z różnymi parametrami t-SNE, takimi jak
perplexityczylearning_rate, aby uzyskać lepszą wizualizację.
9. Przykładowe Funkcje Pomocnicze
Funkcja do Wyświetlania Rekonstrukcji
def plot_reconstructions(model, x_original, num_images=10): reconstructed = model.decoder.predict(model.encoder.predict(x_original)[2]) plt.figure(figsize=(20, 4)) for i in range(num_images): # Oryginalny obraz ax = plt.subplot(2, num_images, i + 1) plt.imshow(x_original[i].squeeze(), cmap='gray') ax.axis('off') # Zrekonstruowany obraz ax = plt.subplot(2, num_images, i + 1 + num_images) plt.imshow(reconstructed[i].squeeze(), cmap='gray') ax.axis('off') plt.tight_layout() plt.show()Przykład użycia:
# Wyświetlenie rekonstrukcji dla Fashion MNIST plot_reconstructions(vae, x_test_fashion, num_images=10)Funkcja do Dodawania SSIM do Funkcji Straty
Jeśli chcesz dodać więcej komponentów do funkcji straty, takich jak SSIM, możesz zmodyfikować klasę VAE w następujący sposób:
class VAE_SSIM(Model): def __init__(self, encoder, decoder, kl_weight=1.0, **kwargs): super(VAE_SSIM, self).__init__(**kwargs) self.encoder = encoder self.decoder = decoder self.kl_weight = kl_weight def compile(self, optimizer, loss_fn=None): super(VAE_SSIM, self).compile() self.optimizer = optimizer self.loss_fn = loss_fn def train_step(self, data): if isinstance(data, tuple): data = data[0] with tf.GradientTape() as tape: z_mean, z_log_var, z = self.encoder(data) reconstruction = self.decoder(z) # Binary crossentropy loss reconstruction_loss = tf.reduce_mean( tf.reduce_sum( binary_crossentropy(data, reconstruction), axis=[1, 2, 3] ) ) # SSIM loss ssim_loss = 1 - tf.reduce_mean(tf.image.ssim(data, reconstruction, max_val=1.0)) # Dywergencja KL kl_loss = -0.5 * tf.reduce_mean( tf.reduce_sum(1 + z_log_var - tf.square(z_mean) - tf.exp(z_log_var), axis=1) ) # Całkowita strata total_loss = reconstruction_loss + self.kl_weight * kl_loss + ssim_loss grads = tape.gradient(total_loss, self.trainable_weights) self.optimizer.apply_gradients(zip(grads, self.trainable_weights)) return {"loss": total_loss, "reconstruction_loss": reconstruction_loss, "kl_loss": kl_loss, "ssim_loss": ssim_loss}Przykład Trenowania z SSIM:
# Inicjalizacja VAE z SSIM vae_ssim = VAE_SSIM(encoder, decoder, kl_weight=1.0) vae_ssim.compile(optimizer=tf.keras.optimizers.Adam()) # Trenowanie history_ssim = vae_ssim.fit(x_train_fashion, epochs=epochs, batch_size=batch_size, validation_data=(x_test_fashion, None))Podsumowanie
Powyższy zestaw kodów obejmuje wszystkie kluczowe aspekty opisywane w artykule dotyczące rozszerzenia modelu Variational Autoencoder (VAE) do generowania bardziej złożonych danych. Obejmuje on:
- Przygotowanie i wczytywanie różnych zbiorów danych (MNIST, Fashion MNIST, CIFAR-10, CelebA).
- Definicję konwolucyjnych enkodera i dekodera, które lepiej uchwycają lokalne wzorce w danych obrazowych.
- Implementację klasy VAE z możliwością ważenia dywergencji KL, co pozwala na kontrolowanie balansu między jakością rekonstrukcji a regularnością przestrzeni latentnej.
- Funkcje do trenowania modelu, wykonywania interpolacji w przestrzeni latentnej oraz wizualizacji tej przestrzeni.
Możesz dostosować poszczególne części kodu do swoich specyficznych potrzeb, na przykład zmieniając architekturę modelu, dodając dodatkowe składniki do funkcji straty czy eksperymentując z różnymi parametrami trenowania. Pamiętaj również o odpowiednim przygotowaniu i przetworzeniu danych, zwłaszcza w przypadku dużych zbiorów danych, takich jak CelebA.
Jeśli masz dodatkowe pytania lub potrzebujesz dalszej pomocy w dostosowywaniu tego kodu, śmiało pytaj!