Kompresja obrazu przy użyciu autoenkoderów w Keras
Wstęp
Autoenkodery to model głębokiego uczenia się służący do przekształcania danych z przestrzeni wielowymiarowej do przestrzeni niskowymiarowej. Działają poprzez kodowanie danych, niezależnie od ich rozmiaru, do wektora 1-D. Wektor ten można następnie zdekodować w celu zrekonstruowania oryginalnych danych (w tym przypadku obrazu). Im dokładniejszy jest autoenkoder, tym bliższe wygenerowane dane są oryginałowi.
W tym samouczku przyjrzymy się architekturze autoenkodera i zobaczymy, jak możemy zastosować ten model do kompresji obrazów ze zbioru danych MNIST przy użyciu TensorFlow i Keras. W szczególności rozważymy:
- Modelowanie dyskryminacyjne a modelowanie generatywne
- Jak działają autoenkodery
Budowanie autoenkodera w Keras
- Budowa kodera
- Budowa dekodera
Warunki wstępne
- Podstawowa znajomość języka Python: Znajomość programowania w języku Python jest niezbędna.
- Zrozumienie sieci neuronowych: Podstawowa wiedza na temat sieci neuronowych, w tym warstw, funkcji aktywacji i procesów szkoleniowych.
- Keras i TensorFlow: Podstawowa znajomość Keras i TensorFlow, w tym instalacja i użytkowanie.
- Numpy i Matplotlib: Znajomość NumPy do manipulacji danymi i Matplotlib do kreślenia i wizualizacji danych.
- Pojęcia dotyczące przetwarzania obrazu: Podstawowa wiedza na temat formatów obrazów i sposobu, w jaki obrazy są reprezentowane jako tablice.
Modelowanie dyskryminacyjne a modelowanie generatywne
Najpopularniejszym rodzajem modeli uczenia maszynowego są modele dyskryminacyjne. Jeśli jesteś entuzjastą uczenia maszynowego, prawdopodobnie typ modeli, które zbudowałeś lub wykorzystałeś, miał głównie charakter dyskryminujący. Modele te rozpoznają dane wejściowe, a następnie podejmują odpowiednie działania. W przypadku zadania klasyfikacyjnego model dyskryminacyjny uczy się, jak rozróżniać różne klasy. Na podstawie wiedzy modelu o właściwościach każdej klasy klasyfikuje nową próbkę wejściową do odpowiedniej etykiety. Zastosujmy to zrozumienie do następnego obrazu przedstawiającego znak ostrzegawczy.
Jeśli model uczenia maszynowego/głębokiego ma rozpoznać następujący obraz, może zrozumieć, że składa się on z trzech głównych elementów: prostokąta, linii i kropki. Jeżeli inny obraz wejściowy ma cechy przypominające te elementy, to również należy to uznać za znak ostrzegawczy.
Jeśli algorytm jest w stanie zidentyfikować właściwości obrazu, czy może wygenerować nowy, podobny do niego obraz? Innymi słowy, czy mógłby narysować nowy obraz składający się z trójkąta, linii i kropki? Niestety modele dyskryminacyjne nie są wystarczająco sprytne, aby narysować nowe obrazy, nawet jeśli znają strukturę tych obrazów. Weźmy inny przykład, żeby wszystko było jaśniejsze.
Załóżmy, że jest ktoś, kto potrafi dobrze rozpoznać pewne rzeczy. Potrafi z łatwością zidentyfikować istotne cechy danego obrazu i następnie sklasyfikować obraz. Czy konieczne jest, aby taka osoba mogła ponownie narysować taki obraz? Nie. Niektórzy ludzie nie potrafią rysować. Modele dyskryminacyjne są jak ludzie, którzy potrafią po prostu rozpoznawać obrazy, ale nie potrafią ich samodzielnie narysować.
W przeciwieństwie do modeli dyskryminacyjnych istnieje inna grupa zwana modelami generatywnymi, która może tworzyć nowe obrazy. Dla danego obrazu wejściowego wyjściem modelu dyskryminacyjnego jest etykieta klasy; Wynikiem modelu generatywnego jest obraz o tym samym rozmiarze i podobnym wyglądzie, co obraz wejściowy.
Jednym z najprostszych modeli generatywnych jest autoenkoder (w skrócie AE), na którym skupia się ten samouczek.
Jak działają autoenkodery
Autoenkodery to model głębokiej sieci neuronowej, który może pobierać dane, propagować je przez wiele warstw w celu skondensowania i zrozumienia ich struktury, a na koniec ponownie wygenerować te dane. W tym samouczku rozważymy, jak to działa w szczególności w przypadku danych obrazu. Aby wykonać to zadanie, autoenkoder wykorzystuje dwa różne typy sieci. Pierwszy nazywa się koderem, a drugi dekoderem. Dekoder jest tylko odbiciem warstw wewnątrz kodera. Wyjaśnijmy, jak to działa.
Zadaniem kodera jest zaakceptowanie oryginalnych danych (np. obrazu), które mogą mieć dwa lub więcej wymiarów i wygenerowanie pojedynczego wektora 1-D reprezentującego cały obraz. Liczba elementów wektora 1-D różni się w zależności od rozwiązywanego zadania. Może mieć 1 lub więcej elementów. Im mniej elementów w wektorze, tym większa złożoność dokładnego odtworzenia oryginalnego obrazu.
Reprezentując obraz wejściowy w wektorze składającym się ze stosunkowo niewielu elementów, w rzeczywistości kompresujemy obraz. Na przykład rozmiar każdego obrazu w zbiorze danych MNIST (którego użyjemy w tym samouczku) to 28x28. Oznacza to, że każdy obraz zawiera elementy 784. Jeśli każdy obraz jest skompresowany tak, aby był reprezentowany za pomocą tylko dwóch elementów, oszczędziliśmy elementy 782, a tym samym (782/784)*100=99,745% danych.
Następny rysunek pokazuje, jak koder generuje wektor 1-D z obrazu wejściowego. Dołączone warstwy są wybierane przez Ciebie, więc możesz używać gęstych, splotowych, przerywanych itp.
Wektor 1-D wygenerowany przez koder z jego ostatniej warstwy jest następnie przesyłany do dekodera. Zadaniem dekodera jest odtworzenie oryginalnego obrazu z zachowaniem najwyższej możliwej jakości. Dekoder jest tylko odbiciem kodera. Zgodnie z architekturą kodera przedstawioną na poprzednim rysunku, architekturę dekodera przedstawiono na rysunku następnym.
Stratę oblicza się poprzez porównanie obrazów oryginalnych i zrekonstruowanych, tj. poprzez obliczenie różnicy pomiędzy pikselami na 2 obrazach. Należy pamiętać, że sygnał wyjściowy dekodera musi mieć ten sam rozmiar co obraz oryginalny. Dlaczego? Ponieważ jeśli rozmiar obrazów jest inny, nie ma możliwości obliczenia straty.
Po omówieniu działania autoenkodera zbudujmy nasz pierwszy autoenkoder przy użyciu Keras.
Budowanie autoenkodera w Keras
Keras to potężne narzędzie do budowania modeli maszynowych i modeli głębokiego uczenia się, ponieważ jest proste i abstrakcyjne, więc przy niewielkim kodzie można osiągnąć świetne rezultaty. Keras ma trzy sposoby budowania modelu:
- Sekwencyjne API
- Funkcjonalne API
- Podklasa modelu
Te trzy sposoby różnią się dozwolonym poziomem dostosowania.
Sekwencyjny interfejs API umożliwia budowanie modeli sekwencyjnych, ale jego dostosowywanie jest mniejsze w porównaniu z pozostałymi dwoma typami. Dane wyjściowe każdej warstwy w modelu są połączone tylko z jedną warstwą.
Chociaż w tym samouczku chcemy stworzyć taki model, skorzystamy z funkcjonalnego interfejsu API. Funkcjonalne API jest proste, bardzo podobne do sekwencyjnego API, a także obsługuje dodatkowe funkcje, takie jak możliwość łączenia danych wyjściowych pojedynczej warstwy z wieloma warstwami.
Ostatnią opcją budowania modelu Keras jest podklasa modelu, która jest w pełni konfigurowalna, ale jednocześnie bardzo złożona. Więcej informacji na temat tych trzech metod znajdziesz w tym samouczku.
Teraz skupimy się na wykorzystaniu funkcjonalnego API do zbudowania autoenkodera. Można by pomyśleć, że zbudujemy pojedynczy model Keras do reprezentowania autoenkodera, ale w rzeczywistości zbudujemy trzy modele: jeden dla kodera, drugi dla dekodera i jeszcze jeden dla całego autoenkodera. Dlaczego budujemy model zarówno dla kodera, jak i dekodera? Robimy to w przypadku, gdy chcesz poznać każdy model z osobna. Na przykład możemy użyć modelu kodera do wizualizacji wektora 1-D reprezentującego każdy obraz wejściowy, co może pomóc w ustaleniu, czy jest to dobra reprezentacja obrazu, czy nie. Dzięki dekoderowi będziemy mogli sprawdzić, czy tworzone są dobre reprezentacje z wektorów 1-D, zakładając, że są one dobrze zakodowane (tj. lepsze do celów debugowania). Wreszcie, budując model dla całego autoenkodera, możemy z łatwością użyć kompleksowo, dostarczając mu oryginalny obraz i bezpośrednio odbierając obraz wyjściowy.
Zacznijmy od zbudowania modelu kodera.
Budowa kodera
Poniższy kod tworzy model kodera przy użyciu funkcjonalnego interfejsu API. Na początku warstwy modelu tworzone są przy użyciu API tensorflow.keras.layers, ponieważ jako biblioteki backendowej używamy TensorFlow. Pierwsza warstwa to warstwa Input, która akceptuje oryginalny obraz. Warstwa ta akceptuje argument o nazwie shape reprezentujący rozmiar danych wejściowych, który zależy od używanego zbioru danych. Będziemy używać zbioru danych MNIST, w którym rozmiar każdego obrazu wynosi 28x28. Zamiast ustawiać kształt na (28, 28), ustawia się go po prostu na (784). Dlaczego? Ponieważ w sieci będziemy używać tylko gęstych warstw, dlatego dane wejściowe muszą mieć postać wektora, a nie macierzy. Tensor reprezentujący warstwę wejściową jest zwracany do zmiennej x.
Warstwa wejściowa jest następnie propagowana przez kilka warstw:
Gęstawarstwa z 300 neuronami- Warstwa
LeakyReLU Gęstawarstwa z 2 neuronami- Warstwa
LeakyReLU
Ostatnia Dense warstwa w sieci ma tylko dwa neurony. Po podaniu do warstwy LeakyReLU końcowy wynik kodera będzie wektorem 1-D zawierającym tylko dwa elementy. Innymi słowy, wszystkie obrazy w zbiorze danych MNIST zostaną zakodowane jako wektory dwóch elementów.
import tensorflow.keras.layers
import tensorflow.keras.models
x = tensorflow.keras.layers.Input(shape=(784), name="encoder_input")
encoder_dense_layer1 = tensorflow.keras.layers.Dense(units=300, name="encoder_dense_1")(x)
encoder_activ_layer1 = tensorflow.keras.layers.LeakyReLU(name="encoder_leakyrelu_1")(encoder_dense_layer1)
encoder_dense_layer2 = tensorflow.keras.layers.Dense(units=2, name="encoder_dense_2")(encoder_activ_layer1)
encoder_output = tensorflow.keras.layers.LeakyReLU(name="encoder_output")(encoder_dense_layer2)
Po zbudowaniu i połączeniu wszystkich warstw kolejnym krokiem jest zbudowanie modelu przy użyciu API tensorflow.keras.models poprzez określenie tensorów wejściowych i wyjściowych zgodnie z następną linią:
encoder = tensorflow.keras.models.Model(x, encoder_output, name="encoder_model")
Aby wydrukować podsumowanie architektury kodera, użyjemy funkcji encoder.summary(). Dane wyjściowe znajdują się poniżej. Ta sieć nie jest duża i możesz zwiększyć liczbę neuronów w gęstej warstwie o nazwie encoder_dense_1, ale właśnie użyłem 300 neuronów, aby uniknąć czasochłonnego uczenia sieci.
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
encoder_input (InputLayer) [(None, 784)] 0
_________________________________________________________________
encoder_dense_1 (Dense) (None, 300) 235500
_________________________________________________________________
encoder_leakyrelu_1 (LeakyRe (None, 300) 0
_________________________________________________________________
encoder_dense_2 (Dense) (None, 2) 602
_________________________________________________________________
encoder_output (LeakyReLU) (None, 2) 0
=================================================================
Total params: 236,102
Trainable params: 236,102
Non-trainable params: 0
_________________________________________________________________
Po zbudowaniu kodera następuje praca nad dekoderem.
Budowa dekodera
Podobnie jak w przypadku budowania kodera, dekoder zostanie zbudowany przy użyciu następującego kodu. Ponieważ warstwa wejściowa dekodera akceptuje sygnał wyjściowy zwrócony przez ostatnią warstwę w koderze, musimy upewnić się, że te 2 warstwy pasują pod względem rozmiaru. Ostatnia warstwa w koderze zwraca wektor składający się z 2 elementów, dlatego na wejściu dekodera muszą znajdować się 2 neurony. Można łatwo zauważyć, że warstwy dekodera są po prostu odbiciem warstw w koderze.
decoder_input = tensorflow.keras.layers.Input(shape=(2), name="decoder_input")
decoder_dense_layer1 = tensorflow.keras.layers.Dense(units=300, name="decoder_dense_1")(decoder_input)
decoder_activ_layer1 = tensorflow.keras.layers.LeakyReLU(name="decoder_leakyrelu_1")(decoder_dense_layer1)
decoder_dense_layer2 = tensorflow.keras.layers.Dense(units=784, name="decoder_dense_2")(decoder_activ_layer1)
decoder_output = tensorflow.keras.layers.LeakyReLU(name="decoder_output")(decoder_dense_layer2)
Po połączeniu warstw następuje zbudowanie modelu dekodera zgodnie z następną linijką.
decoder = tensorflow.keras.models.Model(decoder_input, decoder_output, name="decoder_model")
Oto wynik decoder.summary(). Bardzo ważne jest, aby upewnić się, że rozmiar sygnału wyjściowego zwróconego przez koder odpowiada oryginalnemu rozmiarowi wejściowemu.
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
decoder_input (InputLayer) [(None, 2)] 0
_________________________________________________________________
decoder_dense_1 (Dense) (None, 300) 900
_________________________________________________________________
decoder_leakyrelu_1 (LeakyRe (None, 300) 0
_________________________________________________________________
decoder_dense_2 (Dense) (None, 784) 235984
_________________________________________________________________
decoder_output (LeakyReLU) (None, 784) 0
=================================================================
Total params: 236,884
Trainable params: 236,884
Non-trainable params: 0
_________________________________________________________________
Po zbudowaniu dwóch bloków autoenkodera (kodera i dekodera) następuje zbudowanie kompletnego autoenkodera.
Budowa autoenkodera
Kod budujący autoenkoder znajduje się poniżej. Tensor o nazwie ae_input reprezentuje warstwę wejściową, która akceptuje wektor o długości 784. Tensor ten jest podawany do modelu kodera jako sygnał wejściowy. Dane wyjściowe z kodera są zapisywane w pliku ae_encoder_output, który następnie jest przesyłany do dekodera. Na koniec wyjście autoenkodera jest zapisywane w ae_decoder_output.
Tworzony jest model autoenkodera, który akceptuje wejście ae_input i wyjście ae_decoder_output.
ae_input = tensorflow.keras.layers.Input(shape=(784), name="AE_input")
ae_encoder_output = encoder(ae_input)
ae_decoder_output = decoder(ae_encoder_output)
ae = tensorflow.keras.models.Model(ae_input, ae_decoder_output, name="AE")
Podsumowanie działania autoenkodera znajduje się poniżej. Tutaj można stwierdzić, że kształt wejścia i wyjścia z autoenkodera jest identyczny, co jest niezbędne do obliczenia straty.
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
AE_input (InputLayer) [(None, 784)] 0
_________________________________________________________________
encoder_model (Model) (None, 2) 236102
_________________________________________________________________
decoder_model (Model) (None, 784) 236884
=================================================================
Total params: 472,986
Trainable params: 472,986
Non-trainable params: 0
_________________________________________________________________
Kolejnym krokiem w procesie budowy modelu jest skompilowanie modelu metodą compile() zgodnie z kolejnym kodem. Używana jest funkcja straty średni błąd kwadratowy i używany jest optymalizator Adama z szybkością uczenia ustawioną na 0,0005.
import tensorflow.keras.optimizers
ae.compile(loss="mse", optimizer=tensorflow.keras.optimizers.Adam(lr=0.0005))
Model jest teraz gotowy do przyjęcia danych uczących, dlatego kolejnym krokiem jest przygotowanie danych do wprowadzenia do modelu.
Pamiętaj tylko, że istnieją 3 modele, którymi są:
- koder
- dekoder
- ae (dla autoenkodera)
Ładowanie zbioru danych MNIST i autoenkodera szkoleniowego
Keras ma interfejs API o nazwie tensorflow.keras.datasets, w którym można używać wielu zestawów danych. Będziemy korzystać ze zbioru danych MNIST, który ładowany jest zgodnie z kolejnym kodem. Zestaw danych jest ładowany jako tablice NumPy reprezentujące dane szkoleniowe, dane testowe, etykiety pociągów i etykiety testowe. Zauważ, że nie jesteśmy w ogóle zainteresowani używaniem etykiet klas podczas uczenia modelu, ale służą one jedynie do wyświetlania wyników.
Tablice x_train_orig i x_test_orig NumPy przechowują dane obrazu MNIST, gdzie rozmiar każdego obrazu wynosi 28x28. Ponieważ nasz model akceptuje obrazy jako wektory o długości 784, wówczas tablice te są przekształcane za pomocą funkcji numpy.reshape().
import tensorflow.keras.datasets
import numpy
(x_train_orig, y_train), (x_test_orig, y_test) = tensorflow.keras.datasets.mnist.load_data()
x_train_orig = x_train_orig.astype("float32") / 255.0
x_test_orig = x_test_orig.astype("float32") / 255.0
x_train = numpy.reshape(x_train_orig, newshape=(x_train_orig.shape[0], numpy.prod(x_train_orig.shape[1:])))
x_test = numpy.reshape(x_test_orig, newshape=(x_test_orig.shape[0], numpy.prod(x_test_orig.shape[1:])))
W tej chwili możemy wytrenować autoenkoder za pomocą metody fit w następujący sposób:
ae.fit(x_train, x_train, epochs=20, batch_size=256, shuffle=True, validation_data=(x_test, x_test))
Należy zauważyć, że dane wejściowe i wyjściowe danych szkoleniowych są ustawione na x_train, ponieważ przewidywane dane wyjściowe są identyczne z oryginalnymi danymi wejściowymi. To samo dotyczy danych walidacyjnych. Możesz zmienić liczbę epok i wielkość partii na inne wartości.
Po przeszkoleniu autoenkodera należy dokonać prognoz.
Dokonywanie prognoz
Metoda predict() jest używana w następnym kodzie w celu zwrócenia danych wyjściowych zarówno modelu kodera, jak i dekodera. Tablica encoded_images NumPy zawiera wektory 1D reprezentujące wszystkie obrazy szkoleniowe. Model dekodera akceptuje tę tablicę w celu rekonstrukcji oryginalnych obrazów.
encoded_images = encoder.predict(x_train)
decoded_images = decoder.predict(encoded_images)
Należy zauważyć, że wyjściem dekodera jest wektor 1D o długości 784. Aby wyświetlić zrekonstruowane obrazy, sygnał wyjściowy dekodera jest przekształcany do 28x28 w następujący sposób:
decoded_images_orig = numpy.reshape(decoded_images, newshape=(decoded_images.shape[0], 28, 28))
Następny kod używa Matplotlib do wyświetlenia oryginalnych i zrekonstruowanych obrazów 5 losowych próbek.
num_images_to_show = 5
for im_ind in range(num_images_to_show):
plot_ind = im_ind*2 + 1
rand_ind = numpy.random.randint(low=0, high=x_train.shape[0])
matplotlib.pyplot.subplot(num_images_to_show, 2, plot_ind)
matplotlib.pyplot.imshow(x_train_orig[rand_ind, :, :], cmap="gray")
matplotlib.pyplot.subplot(num_images_to_show, 2, plot_ind+1)
matplotlib.pyplot.imshow(decoded_images_orig[rand_ind, :, :], cmap="gray")
Na kolejnym rysunku przedstawiono 5 oryginalnych obrazów i ich rekonstrukcję. Widać, że autoenkoder jest w stanie przynajmniej zrekonstruować obraz zbliżony do oryginału, ale jakość jest niska.
Jedną z przyczyn niskiej jakości jest wykorzystanie małej liczby neuronów (300) w gęstej warstwie. Innym powodem jest użycie tylko 2 elementów do reprezentowania wszystkich obrazów. Jakość można poprawić, używając większej liczby elementów, ale zwiększa to rozmiar skompresowanych danych.
Innym powodem jest całkowite nieużywanie warstw splotowych. Warstwy gęste są dobre do przechwytywania właściwości globalnych z obrazów, a warstwy splotowe są dobre do właściwości lokalnych. Wynik można poprawić, dodając kilka warstw splotowych.
Aby lepiej zrozumieć wyjście modelu kodera, wyświetlmy wszystkie wektory 1D, które zwraca, zgodnie z następnym kodem.
matplotlib.pyplot.figure()
matplotlib.pyplot.scatter(encoded_images[:, 0], encoded_images[:, 1], c=y_train)
matplotlib.pyplot.colorbar()
Wykres wygenerowany przez ten kod pokazano poniżej. Ogólnie rzecz biorąc, można zauważyć, że model jest w stanie grupować różne obrazy w różnych regionach, ale różne skupienia nakładają się na siebie.
## Complete Code
The complete code discussed in this tutorial is listed below.
import tensorflow.keras.layers
import tensorflow.keras.models
import tensorflow.keras.optimizers
import tensorflow.keras.datasets
import numpy
import matplotlib.pyplot
Encoder
x = tensorflow.keras.layers.Input(shape=(784), name="encoder_input")
encoder_dense_layer1 = tensorflow.keras.layers.Dense(units=300, name="encoder_dense_1")(x)
encoder_activ_layer1 = tensorflow.keras.layers.LeakyReLU(name="encoder_leakyrelu_1")(encoder_dense_layer1)
encoder_dense_layer2 = tensorflow.keras.layers.Dense(units=2, name="encoder_dense_2")(encoder_activ_layer1)
encoder_output = tensorflow.keras.layers.LeakyReLU(name="encoder_output")(encoder_dense_layer2)
encoder = tensorflow.keras.models.Model(x, encoder_output, name="encoder_model")
encoder.summary()
Decoder
decoder_input = tensorflow.keras.layers.Input(shape=(2), name="decoder_input")
decoder_dense_layer1 = tensorflow.keras.layers.Dense(units=300, name="decoder_dense_1")(decoder_input)
decoder_activ_layer1 = tensorflow.keras.layers.LeakyReLU(name="decoder_leakyrelu_1")(decoder_dense_layer1)
decoder_dense_layer2 = tensorflow.keras.layers.Dense(units=784, name="decoder_dense_2")(decoder_activ_layer1)
decoder_output = tensorflow.keras.layers.LeakyReLU(name="decoder_output")(decoder_dense_layer2)
decoder = tensorflow.keras.models.Model(decoder_input, decoder_output, name="decoder_model")
decoder.summary()
Autoencoder
ae_input = tensorflow.keras.layers.Input(shape=(784), name="AE_input")
ae_encoder_output = encoder(ae_input)
ae_decoder_output = decoder(ae_encoder_output)
ae = tensorflow.keras.models.Model(ae_input, ae_decoder_output, name="AE")
ae.summary()
RMSE
def rmse(y_true, y_predict):
return tensorflow.keras.backend.mean(tensorflow.keras.backend.square(y_true-y_predict))
AE Compilation
ae.compile(loss="mse", optimizer=tensorflow.keras.optimizers.Adam(lr=0.0005))
Preparing MNIST Dataset
(x_train_orig, y_train), (x_test_orig, y_test) = tensorflow.keras.datasets.mnist.load_data()
x_train_orig = x_train_orig.astype("float32") / 255.0
x_test_orig = x_test_orig.astype("float32") / 255.0
x_train = numpy.reshape(x_train_orig, newshape=(x_train_orig.shape[0], numpy.prod(x_train_orig.shape[1:])))
x_test = numpy.reshape(x_test_orig, newshape=(x_test_orig.shape[0], numpy.prod(x_test_orig.shape[1:])))
Training AE
ae.fit(x_train, x_train, epochs=20, batch_size=256, shuffle=True, validation_data=(x_test, x_test))
encoded_images = encoder.predict(x_train)
decoded_images = decoder.predict(encoded_images)
decoded_images_orig = numpy.reshape(decoded_images, newshape=(decoded_images.shape[0], 28, 28))
num_images_to_show = 5
for im_ind in range(num_images_to_show):
plot_ind = im_ind*2 + 1
rand_ind = numpy.random.randint(low=0, high=x_train.shape[0])
matplotlib.pyplot.subplot(num_images_to_show, 2, plot_ind)
matplotlib.pyplot.imshow(x_train_orig[rand_ind, :, :], cmap="gray")
matplotlib.pyplot.subplot(num_images_to_show, 2, plot_ind+1)
matplotlib.pyplot.imshow(decoded_images_orig[rand_ind, :, :], cmap="gray")
matplotlib.pyplot.figure()
matplotlib.pyplot.scatter(encoded_images[:, 0], encoded_images[:, 1], c=y_train)
matplotlib.pyplot.colorbar()
Wniosek
W tym samouczku przedstawiono model generatywny głębokiego uczenia się, znany jako autoenkodery. Model ten składa się z dwóch elementów: kodera i dekodera. Ten pierwszy koduje dane wejściowe jako wektory 1-D, które następnie należy dekodować w celu zrekonstruowania oryginalnych danych. Widzieliśmy, jak zastosować ten model za pomocą Keras do kompresji obrazów ze zbioru danych MNIST w zamian za zastosowanie autoenkodera używającego Keras do kompresji zbioru danych MNIST w zaledwie 2 elementach.




