Dodatkowo dodaj kody umożliwiające wygenerowanie grafik ilustrujących skuteczność i…
- User
Dodatkowo dodaj kody umożliwiające wygenerowanie grafik ilustrujących skuteczność i jakość przeprowadzonego szkolenia, analizę podziel na analizę danych zbioru Fashion, Cifar-10, cifar-100, CelebA, zachowaj odwołanie do wcześniejszej implementacji: \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{itemize}[noitemsep,nolistsep] \item Wybrano bardziej złożony zbiór danych do treningu modelu. \item Zmodyfikowano architekturę modelu, wprowadzając konwolucyjne warstwy i pogłębiając sieć. \item Przeprowadzono eksperymenty z różnymi wymiarami przestrzeni latentnej . \item Zbadano wpływ zmiany wagi komponentu dywergencji KL w funkcji straty na jakość generowanych danych. \item Wykonano interpolacje w przestrzeni latentnej oraz wizualizację przestrzeni latentnej przy użyciu algorytmów redukcji wymiarów. \end{itemize}
\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 zbiór danych \textbf{Fashion MNIST} \cite{Xiao2017}. Jest to zbiór zawierający 60 000 obrazów treningowych i 10 000 obrazów testowych, przedstawiających różne elementy odzieży w skali szarości o rozmiarze pikseli. Dane te są bardziej złożone niż cyfry z MNIST, co stanowi większe wyzwanie dla modelu. Dodatkowo, rozważano również zbiór \textbf{CIFAR-10} \cite{Krizhevsky2009}, zawierający kolorowe obrazy o jeszcze większej złożoności, jednak ze względu na ograniczenia obliczeniowe skupiono się na Fashion MNIST.
\subsection{Zmiana architektury modelu}
\subsubsection{Zastosowanie konwolucyjnego VAE}
W celu lepszego uchwycenia złożonych wzorców w danych obrazowych, wprowadzono warstwy konwolucyjne do enkodera i dekodera. Pozwala to modelowi na wykorzystanie informacji o lokalnych zależnościach między pikselami.
\subsubsection{Pogłębienie sieci}
Dodano więcej warstw do architektury sieci, zwiększając jej głębokość. Umożliwia to modelowi uczenie się bardziej abstrakcyjnych reprezentacji danych.
\subsubsection{Eksperymenty z wymiarem przestrzeni latentnej }
Przeprowadzono eksperymenty z różnymi wymiarami wektora latentnego , takimi jak . Pozwoliło to na zbadanie wpływu wymiaru przestrzeni latentnej na jakość generowanych danych.
\subsection{Implementacja nowego modelu}
\begin{lstlisting}[caption=Implementacja konwolucyjnego VAE, label=code:conv_vae] import numpy as np import tensorflow as tf from tensorflow.keras.datasets import fashion_mnist from tensorflow.keras.layers import Layer, Input, Conv2D, Flatten, Dense, Reshape, Conv2DTranspose from tensorflow.keras.models import Model import matplotlib.pyplot as plt
1. Załadowanie i przygotowanie danych Fashion MNIST
(x_train, _), (x_test, _) = fashion_mnist.load_data()
Normalizacja danych do zakresu [0, 1] i dodanie wymiaru kanału
x_train = x_train.astype('float32') / 255. x_test = x_test.astype('float32') / 255. x_train = np.expand_dims(x_train, axis=-1) # (60000, 28, 28, 1) x_test = np.expand_dims(x_test, axis=-1) # (10000, 28, 28, 1)
2. Definicja wymiaru przestrzeni latentnej
latent_dim = 16 # Można eksperymentować z wartościami 2, 8, 16, 32
3. Definicja warstwy próbkowania
class Sampling(Layer): def call(self, inputs): z_mean, z_log_var = inputs epsilon = tf.keras.backend.random_normal(shape=tf.shape(z_mean)) return z_mean + tf.exp(0.5 * z_log_var) * epsilon
4. Definicja enkodera
def build_encoder(): inputs = Input(shape=(28, 28, 1)) 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 = Flatten()(x) x = Dense(64, 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]) # Warstwa próbkowania encoder = Model(inputs, [z_mean, z_log_var, z], name='encoder') return encoder
5. Definicja dekodera
def build_decoder(): latent_inputs = Input(shape=(latent_dim,)) x = Dense(7 * 7 * 64, activation='relu')(latent_inputs) x = Reshape((7, 7, 64))(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) outputs = Conv2DTranspose(1, kernel_size=3, activation='sigmoid', padding='same')(x) decoder = Model(latent_inputs, outputs, name='decoder') return decoder
6. Budowa modelu VAE
encoder = build_encoder() decoder = build_decoder()
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 self.reconstruction_loss_tracker = tf.keras.metrics.Mean(name="reconstruction_loss") self.kl_loss_tracker = tf.keras.metrics.Mean(name="kl_loss")
def call(self, inputs): z_mean, z_log_var, z = self.encoder(inputs) reconstruction = self.decoder(z) return reconstruction def train_step(self, data): with tf.GradientTape() as tape: z_mean, z_log_var, z = self.encoder(data) reconstruction = self.decoder(z) reconstruction_loss = tf.reduce_mean( tf.reduce_sum( tf.keras.losses.binary_crossentropy(data, reconstruction), axis=(1, 2) ) ) kl_loss = -0.5 * tf.reduce_mean( tf.reduce_sum( z_log_var - tf.square(z_mean) - tf.exp(z_log_var) + 1, axis=1 ) ) 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)) # Update metrics self.reconstruction_loss_tracker.update_state(reconstruction_loss) self.kl_loss_tracker.update_state(kl_loss) return {"loss": total_loss, "reconstruction_loss": self.reconstruction_loss_tracker.result(), "kl_loss": self.kl_loss_tracker.result()} def test_step(self, data): z_mean, z_log_var, z = self.encoder(data) reconstruction = self.decoder(z) reconstruction_loss = tf.reduce_mean( tf.reduce_sum( tf.keras.losses.binary_crossentropy(data, reconstruction), axis=(1, 2) ) ) kl_loss = -0.5 * tf.reduce_mean( tf.reduce_sum( z_log_var - tf.square(z_mean) - tf.exp(z_log_var) + 1, axis=1 ) ) total_loss = reconstruction_loss + self.kl_weight * kl_loss # Update metrics self.reconstruction_loss_tracker.update_state(reconstruction_loss) self.kl_loss_tracker.update_state(kl_loss) return {"loss": total_loss, "reconstruction_loss": self.reconstruction_loss_tracker.result(), "kl_loss": self.kl_loss_tracker.result()} @property def metrics(self): return [self.reconstruction_loss_tracker, self.kl_loss_tracker]vae = VAE(encoder, decoder, kl_weight=1.0) vae.compile(optimizer='adam') \end{lstlisting}
\subsection{Trening modelu}
Przeprowadzono trening modelu na danych \textit{Fashion MNIST} przez 30 epok z wykorzystaniem rozmiaru batcha równego 128.
\begin{lstlisting}[caption=Trening konwolucyjnego VAE, label=code:training]
Trening modelu VAE
history = vae.fit(x_train, epochs=30, batch_size=128, validation_data=(x_test, None)) \end{lstlisting}
\subsection{Eksperymenty z funkcją straty}
\subsubsection{Waga komponentu dywergencji KL}
Przeprowadzono eksperymenty z różnymi wartościami wagi komponentu dywergencji KL (\texttt{kl_weight} ), aby zbadać wpływ na balans między jakością rekonstrukcji a regularnością przestrzeni latentnej.
\subsubsection{Dodatkowe termy w funkcji straty}
Dodano dodatkowy składnik w funkcji straty, kładąc większy nacisk na rekonstrukcję detali poprzez zastosowanie miary strat strukturalnych (SSIM).
\begin{lstlisting}[caption=Modyfikacja funkcji straty z użyciem SSIM, label=code:loss_ssim] # Modyfikacja funkcji straty w metodzie train_step def train_step(self, data): with tf.GradientTape() as tape: z_mean, z_log_var, z = self.encoder(data) reconstruction = self.decoder(z) # MSE loss mse_loss = tf.reduce_mean( tf.reduce_sum( tf.keras.losses.mean_squared_error(data, reconstruction), axis=(1, 2) ) ) # SSIM loss ssim_loss = 1 - tf.reduce_mean(tf.image.ssim(data, reconstruction, max_val=1.0)) # Łączny loss rekonstrukcji reconstruction_loss = mse_loss + ssim_loss kl_loss = -0.5 * tf.reduce_mean( tf.reduce_sum( z_log_var - tf.square(z_mean) - tf.exp(z_log_var) + 1, axis=1 ) ) 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)) # Update metrics self.reconstruction_loss_tracker.update_state(reconstruction_loss) self.kl_loss_tracker.update_state(kl_loss) return {"loss": total_loss, "reconstruction_loss": self.reconstruction_loss_tracker.result(), "kl_loss": self.kl_loss_tracker.result()}\end{lstlisting}
\section{Eksperymenty i wyniki}
\subsection{Rekonstrukcja obrazów}
Poniżej przedstawiono porównanie oryginalnych i zrekonstruowanych obrazów dla różnych wymiarów przestrzeni latentnej .
\begin{figure}[H] \centering \includegraphics[width=\textwidth]{vae_reconstructions.png} \caption{Porównanie oryginalnych i zrekonstruowanych obrazów dla różnych wymiarów . Górny rząd: oryginały; dolny rząd: rekonstrukcje.} \label{fig:vae_reconstructions} \end{figure}
\subsection{Interpolacje w przestrzeni latentnej}
Przeprowadzono interpolacje między dwoma punktami w przestrzeni latentnej, generując płynne przejścia między różnymi klasami obiektów.
\begin{lstlisting}[caption=Interpolacje w przestrzeni latentnej, label=code:interpolation]
Wybór dwóch próbek
sample_1 = x_test[0:1] sample_2 = x_test[1:2]
Kodowanie próbek
z_mean_1, _, _ = encoder.predict(sample_1) z_mean_2, _, _ = encoder.predict(sample_2)
Interpolacja liniowa między punktami w przestrzeni latentnej
num_steps = 10 interpolations = [] for alpha in np.linspace(0, 1, num_steps): z = (1 - alpha) * z_mean_1 + alpha * z_mean_2 reconstructed = decoder.predict(z) interpolations.append(reconstructed.reshape(28, 28))
Wyświetlenie interpolacji
plt.figure(figsize=(20, 2)) for i, img in enumerate(interpolations): ax = plt.subplot(1, num_steps, i + 1) plt.imshow(img, cmap='gray') ax.axis('off') plt.show() \end{lstlisting}
\begin{figure}[H] \centering \includegraphics[width=\textwidth]{vae_interpolations.png} \caption{Interpolacje w przestrzeni latentnej między dwoma obrazami.} \label{fig:vae_interpolations} \end{figure}
\subsection{Wizualizacja przestrzeni latentnej}
Aby zobrazować, jak model VAE rozdziela różne klasy obiektów w przestrzeni latentnej, zastosowano redukcję wymiarów do 2D przy użyciu t-SNE.
\begin{lstlisting}[caption=Wizualizacja przestrzeni latentnej za pomocą t-SNE, label=code:tsne] from sklearn.manifold import TSNE
Kodowanie danych testowych
z_means, _, _ = encoder.predict(x_test)
Redukcja wymiarów do 2D
tsne = TSNE(n_components=2, verbose=1) z_2d = tsne.fit_transform(z_means)
Wizualizacja
plt.figure(figsize=(12, 10)) scatter = plt.scatter(z_2d[:, 0], z_2d[:, 1], c=_, cmap='tab10') # Wykorzystanie etykiet klasowych plt.colorbar(scatter) plt.title('Wizualizacja przestrzeni latentnej') plt.xlabel('Wymiar 1') plt.ylabel('Wymiar 2') plt.show() \end{lstlisting}
\begin{figure}[H] \centering \includegraphics[width=0.8\textwidth]{vae_latent_space.png} \caption{Wizualizacja przestrzeni latentnej przy użyciu t-SNE.} \label{fig:vae_latent_space} \end{figure}
\section{Dyskusja}
\subsection{Wpływ wymiaru przestrzeni latentnej}
Zaobserwowano, że zwiększenie wymiaru przestrzeni latentnej poprawia jakość rekonstrukcji, jednak zbyt duży wymiar może prowadzić do nadmiernego dopasowania i utraty właściwości generacyjnych modelu.
\subsection{Waga dywergencji KL}
Zmniejszenie wagi dywergencji KL skutkowało lepszą rekonstrukcją, ale gorszą regularnością przestrzeni latentnej, co przejawiało się w mniej płynnych interpolacjach.
\section{Wnioski}
Przeprowadzone eksperymenty wykazały, że wprowadzenie warstw konwolucyjnych oraz pogłębienie architektury sieci pozwalają na skuteczne modelowanie i generowanie bardziej złożonych danych obrazowych. Dostosowanie parametrów modelu, takich jak wymiar przestrzeni latentnej i waga dywergencji KL, ma znaczący wpływ na jakość generowanych danych.
\section{Prace przyszłe}
W przyszłości planuje się:
\begin{itemize}[noitemsep,nolistsep] \item Zastosowanie modelu do zbiorów danych o jeszcze większej złożoności, takich jak CIFAR-10 czy CelebA. \item Eksperymenty z różnymi rozkładami priory w przestrzeni latentnej. \item Wprowadzenie warunkowych VAE (\textit{Conditional VAE}) umożliwiających kontrolowane generowanie obrazów. \item Badanie wpływu innych funkcji strat i technik regularizacji na jakość generowanych danych. \end{itemize}
\begin{thebibliography}{9}
\bibitem{Kingma2014} Kingma, D. P., & Welling, M. (2014). \textit{Auto-Encoding Variational Bayes}. Proceedings of the International Conference on Learning Representations (ICLR).
\bibitem{Xiao2017} Xiao, H., Rasul, K., & Vollgraf, R. (2017). \textit{Fashion-MNIST: A Novel Image Dataset for Benchmarking Machine Learning Algorithms}. arXiv preprint arXiv:1708.07747.
\bibitem{LeCun1998} LeCun, Y., Bottou, L., Bengio, Y., & Haffner, P. (1998). \textit{Gradient-Based Learning Applied to Document Recognition}. Proceedings of the IEEE, 86(11), 2278-2324.
\bibitem{Krizhevsky2009} Krizhevsky, A. (2009). \textit{Learning Multiple Layers of Features from Tiny Images}. Technical report, University of Toronto.
\end{thebibliography}
\end{document} rozwiń wszystkie punkty wymienione w VAE Cel zadania
Rozwinąć zbudowany wcześniej model VAE, tak aby lepiej uchwycić i generować bardziej złożone dane. Eksplorować różne architektury i parametry modelu VAE. Przeanalizować, jak zmiany w modelu wpływają na jakość generowanych danych.Zadanie: Poprawa i rozszerzenie VAE na bardziej wymagających danych
(4pt) Wybór nowego zbioru danych: Poprzedni model trenowali na MNIST, więc można go rozbudować i przetestować na bardziej złożonym zbiorze danych, np.: Fashion MNIST: Lepsze wyzwanie, bo zawiera obrazy ubrań, które są bardziej skomplikowane niż cyfry. CIFAR-10 lub CIFAR-100: Bardziej zaawansowane obrazy w kolorze, co wprowadza dodatkową złożoność i wymaga użycia konwolucyjnych warstw. CelebA: Zbiór zdjęć twarzy, przydatny do badania jakości generowania realistycznych obrazów ludzi. Ciekawą możliwością jest manipulacja cechami twarzy w przestrzeni latentnej, np. rozpoznawanie emocji. (4pt) Zmiana architektury modelu: Konwolucyjne VAE: Dodanie warstw konwolucyjnych do enkodera i dekodera może poprawić zdolność modelu do uchwycenia złożonych wzorców. Głębsza sieć: Dodanie większej liczby warstw oraz testowanie różnych liczby jednostek w warstwach ukrytych. Eksperymenty z rozmiarami przestrzeni latentnej $z$: Zmniejszenie lub zwiększenie wymiarów wektora latentnego i porównanie jakości generacji. (4pt) Eksperymenty z funkcją straty: Sprawdzenie, jak zmiana wagi komponentu Kullbacka-Leiblera wpływa na balans między rekonstrukcją a regularnością przestrzeni latentnej. Dodanie dodatkowego termu w funkcji straty, który kładzie większy nacisk na rekonstrukcję detali. (4pt) Interpolacje w przestrzeni latentnej: Wygenerowanie próbek obrazów, które są interpolacją pomiędzy dwoma punktami w przestrzeni latentnej. Pozwala to na zaobserwowanie, jak VAE przechodzi między dwoma obrazami i czy generowane obrazy są realistyczne. (4pt) Wizualizacja przestrzeni latentnej: Redukcja przestrzeni latentnej do 2D (PCA lub t-SNE), aby zobaczyć, jak VAE rozdziela różne klasy obiektów. Tworzenie mapy przestrzeni latentnej dla CelebA lub Fashion MNIST, co pozwala na zbadanie klastrów i przejść między różnymi rodzajami ubrań lub cechami twarzy. - Assistant
\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 zbiorami danych 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{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{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ń, 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}[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}[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}
Dane CelebA wymagają pobrania z zewnętrznego źródła i wstępnego przetwarzania, takiego jak skalowanie, przycięcie twarzy itp.
\begin{lstlisting}[caption=Przykładowe ładowanie zbioru CelebA, label=code:celeba] import glob from PIL import Image
Ścieżka do folderu z obrazami CelebA
image_paths = glob.glob('path_to_celeba_images/*.jpg')
Wczytanie i przetwarzanie obrazów
def load_and_preprocess_image(image_path): img = Image.open(image_path) img = img.crop((x, y, x + width, y + height)) # Przycięcie twarzy img = img.resize((64, 64)) img = np.array(img).astype('float32') / 255. return img
x_data_celeba = np.array([load_and_preprocess_image(path) for path in image_paths]) \end{lstlisting}
\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.
\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}
\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.
\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.
\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.
\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ł.
\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.
\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. Wizualizacja przestrzeni latentnej ujawniła, że model grupuje podobne klasy obiektów blisko siebie.
\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.
\section{Prace przyszłe}
W przyszłości planuje się:
\begin{itemize}[noitemsep,nolistsep] \item Zastosowanie \emph{Conditional VAE}, umożliwiających kontrolowane generowanie obrazów na podstawie zadanych atrybutów. \item Eksperymentowanie z innymi funkcjami straty, takimi jak \emph{Perceptual Loss}. \item Zastosowanie modeli \emph{VAE-GAN}, łączących VAE z Generative Adversarial Networks, w celu poprawy jakości generowanych obrazów. \item Badanie wpływu różnych rozkładów priory (np. rozkładów wielomodalnych) w przestrzeni latentnej. \end{itemize}
\begin{thebibliography}{9}
\bibitem{Kingma2014} Kingma, D. P., & Welling, M. (2014). \textit{Auto-Encoding Variational Bayes}. Proceedings of the International Conference on Learning Representations (ICLR).
\bibitem{Xiao2017} Xiao, H., Rasul, K., & Vollgraf, R. (2017). \textit{Fashion-MNIST: A Novel Image Dataset for Benchmarking Machine Learning Algorithms}. arXiv preprint arXiv:1708.07747.
\bibitem{Krizhevsky2009} Krizhevsky, A. (2009). \textit{Learning Multiple Layers of Features from Tiny Images}. Technical report, University of Toronto.
\bibitem{Liu2015} Liu, Z., Luo, P., Wang, X., & Tang, X. (2015). \textit{Deep Learning Face Attributes in the Wild}. Proceedings of the IEEE International Conference on Computer Vision (ICCV).
\end{thebibliography}
\end{document}