labs/lab09-introduction-to-autoencoders.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Úvod do autoenkodérov"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Na dnešnom cvičení sa oboznámime s novým typom neurónových sietí - autoenkodérmi. Autoenkodéry sú neurónové siete, ktoré slúžia na kompresiu údajov, avšak oproti tradičným metódam kompresie nepotrebujeme ich vopred naprogramovať. Ďalšou ich vlastnosťou je že sú špecificky určené na kompresiu údajov podobných ako dáta, na ktorých bola sieť natrénovaná. Podobne ako ďalšie metódy kompresie (napr. mp3, jpeg), aj autoenkodéry robia  stratovú kompresiu.\n",
    "\n",
    "Z topologického hľadiska autoenkodéry sú zvyčajne symetrické (síce nie je to nevyhnutné, v praxi takéto siete sa jednoduchšie trénujú). Cieľom autoenkodérov je kopírovať vstup na výstupe tak, že skryté vrstvy majú menej neurónov ako vstup, resp. výstup. Autoenkodéry teda majú dve časti, prvá (enkodér) má za úlohu skomprimovať údaje, kým druhá časť (dekodér) reprodukuje vstup zo zakódovaného tvaru.\n",
    "\n",
    "![](resources/lab09/autoencoder.png)\n",
    "\n",
    "Dnes si vytvoríme dva jednoduché autoenkodéry pomocou knižnice Keras, najprv bez konvolúcie. Kostru riešenia nájdete [tu](resources/lab09/lab09.py)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Načítanie potrebných knižníc\n",
    "\n",
    "V riešení využijeme už známe knižnice `keras`, `numpy` a `matplotlib` pre vizualizáciu fungovania siete:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from keras.layers import Input, Dense\n",
    "from keras.models import Model\n",
    "from keras.datasets import mnist\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Vizualizácia výsledkov\n",
    "\n",
    "V kóde máte pripravenú funkciu `plot_results`, ktorá slúži na vizualizáciu fungovania siete. Pomocou knižnice `matplotlib` zobrazíme niekoľko ukážkových vstupov, ich zakódovaný tvar a rekonštruovaný obraz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def plot_results(x_test, encoded_imgs, decoded_imgs, n=10):\n",
    "    plt.figure(figsize=(40, 4))\n",
    "    for i in range(n):\n",
    "        # display original\n",
    "        ax = plt.subplot(3, n, i + 1)\n",
    "        plt.imshow(x_test[i].reshape(28, 28))\n",
    "        plt.gray()\n",
    "        ax.get_xaxis().set_visible(False)\n",
    "        ax.get_yaxis().set_visible(False)\n",
    "\n",
    "        # display encoded\n",
    "        ax = plt.subplot(3, n, i + 1 + n)\n",
    "        plt.imshow(encoded_imgs[i].reshape(8, 4))\n",
    "        plt.gray()\n",
    "        ax.get_xaxis().set_visible(False)\n",
    "        ax.get_yaxis().set_visible(False)\n",
    "\n",
    "        # display reconstruction\n",
    "        ax = plt.subplot(3, n, i + 1 + n * 2)\n",
    "        plt.imshow(decoded_imgs[i].reshape(28, 28))\n",
    "        plt.gray()\n",
    "        ax.get_xaxis().set_visible(False)\n",
    "        ax.get_yaxis().set_visible(False)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Príprava údajov\n",
    "\n",
    "Rovnako ako pri predošlých sieťach, aj dnes použijeme dataset rukou písaných číslic MNIST, keďže ale nepoužijeme konvolúciu, tieto obrázky potrebujeme reprezentovať ako jedrozmerné vektory. Pred tým ale pixely normalizujeme, t.j. pretypujeme ich na numpyovský float a hodnoty od 0 po 255 namapujeme do intervalu 0 až 1.\n",
    "\n",
    "Všimnite si, že z datasetu nenačítame labely (nahradíme ich znakom `_`). Dôvodom je, že autoenkodéry by mali mať na výstupe rovnakú hodnotu ako na vstupe, teda stačia nám vstupné údaje z datasetu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "(mnist_train, _), (mnist_test, _) = mnist.load_data()\n",
    "\n",
    "x_train = # TODO: normalize to range 0 to 1\n",
    "x_test = # TODO: normalize to range 0 to 1\n",
    "x_train = # TODO: reshape to a list of one-dimensional vectors\n",
    "x_test = # TODO: reshape to a list of one-dimensional vectors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Shallow autoencoder\n",
    "\n",
    "V ďalšom kroku zadefinujeme najjednoduchší možní autoenkodér: autoenkodér s jednou skrytou vsrtvou.\n",
    "\n",
    "### 4.1. Definícia vrstiev\n",
    "Keďže vrstvy chceme využit niekoľkokrát, namiesto toho, aby sme najprv vytvorili model a postupne sme doňho pridávali vrstvy, teraz najprv zadefinujeme vrstvy, ktoré spojíme pomocou parametrov v tvare:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "dalsia_vrstva = Typ_vrstvy(parametre)(predosla_vrstva)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "input_img = # TODO: define input layer\n",
    "encoded = # TODO: define hidden layer\n",
    "decoded = # TODO: define output layer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2. Definícia modelov\n",
    "Ak už máme vrstvy zadefinované, môžeme pristúpiť k definícii modelov. V tomto kroku zadefinujeme tri modely: celkový autoenkodér, enkodér, a dekodér. Modely autoenkodéra a enkodéra vieme zadefinovať na základe ich vstupu a výstupu v tvare:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "model_object = Model(vstupna_vrstva, vystupna_vrstva)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "autoencoder = # TODO: define autoencoder\n",
    "encoder = # TODO: define encoder"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Definícia modelu čistého dekodéra je menej priamočiara. Jeho vstupom je síce výstup enkodéra, ale nevieme priamo použiť vrstvy z autoenkodéra, keďže tie sú navzájom prepojené. Namiesto toho vytvoríme novú vstupnú vrstvu a následne pridáme ďalšie potrebné vrstvy (v tomto prípade iba poslednú vrstvu autoenkodéra)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "encoded_input = # TODO: define input to decoder\n",
    "decoder_layer = # TODO: define further layer of decoder\n",
    "decoder = # TODO: define decoder"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.3. Trénovanie autoenkodéra\n",
    "\n",
    "Neostáva nám nič iné, len natrénovať našu sieť. Pridajte chýbajúce parametre do volaní funkcií nasledovne:\n",
    "* `optimizer` - napr. adadelta\n",
    "* `loss` - napr. binary_crossentropy\n",
    "* `input` - vstup autoenkodéra\n",
    "* `output` - očakávaný výstup autoenkodéra\n",
    "* `epochs` - napr. 25\n",
    "* `batch_size` - napr. 256\n",
    "* `shuffle` - nastavte na True pre náhodné poradie v trénovacej množine\n",
    "* `verbose` - nastavte na 2 pre jednoduchší výpis progresu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "autoencoder.compile(# TODO: insert parameters: optimizer, loss\n",
    "    )\n",
    "autoencoder.fit(# TODO: insert parameters: input, output, epochs, batch_size, shuffle\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.4. Testovanie autoenkodéra\n",
    "\n",
    "Ak už máme autoenkodér natrénovaný, môžeme vizualizovať jeho funkčnosť. Zavolajte funkciu `predict` nad testovacou množinou. Keďže chceme vizualizovať vstup, zakódovanú reprezentáciu, aj výstup autoenkodéra, funkciu potrebujeme zavolať aj pre enkodér aj pre samotný autoenkodér. Ak chcete testovať zvlášť aj dekodér, upravte kód podľa potreby."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "encoded_imgs = encoder.predict(x_test)\n",
    "decoded_imgs = autoencoder.predict(x_test)\n",
    "\n",
    "plot_results(x_test, encoded_imgs, decoded_imgs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zobrazia sa Vám tri riadky obrázkov, kde prvý riadok je vstup, druhý je zakódovaný tvar, a posledný riadok obsahuje rekonštruované obrázky, t.j. výstup autoenkodéra, napr.\n",
    "\n",
    "![](resources/lab09/autoencoder-shallow.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Deep autoencoder\n",
    "\n",
    "V ďalšom kroku rozšírime našu sieť pridávaním ďalších vrstiev (samotná topológia je na Vás, nižšie máte uvedený príklad). Odporúčame Vám použiť aktivačnú funkciu `relu` až na poslednú vrstvu, kde sa použije `sigmoid`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "Layer (type)                 Output Shape              Param #   \n",
    "_________________________________________________________________\n",
    "input_1 (InputLayer)         (None, 784)               0         \n",
    "_________________________________________________________________\n",
    "dense_1 (Dense)              (None, 128)               100480    \n",
    "_________________________________________________________________\n",
    "dense_2 (Dense)              (None, 64)                8256      \n",
    "_________________________________________________________________\n",
    "dense_3 (Dense)              (None, 32)                2080      \n",
    "_________________________________________________________________\n",
    "dense_4 (Dense)              (None, 64)                2112      \n",
    "_________________________________________________________________\n",
    "dense_5 (Dense)              (None, 128)               8320      \n",
    "_________________________________________________________________\n",
    "dense_6 (Dense)              (None, 784)               101136    \n",
    "_________________________________________________________________\n",
    "Total params: 222,384\n",
    "Trainable params: 222,384\n",
    "Non-trainable params: 0\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.1. Definícia vrstiev\n",
    "\n",
    "Zadefinujte jednotlivé vrstvy hlbokej neurónovej siete podobne ako v bode 4.1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "input_img = # TODO: define input layer\n",
    "encoded_1 = # TODO: define next layer; activation relu\n",
    "encoded_2 = # TODO: define next layer; activation relu\n",
    "encoded_3 = # TODO: define next layer; activation relu\n",
    "\n",
    "decoded_1 = # TODO: define next layer; activation relu\n",
    "decoded_2 = # TODO: define next layer; activation relu\n",
    "decoded_3 = # TODO: define next layer; activation sigmoid"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. 2. Definícia modelov\n",
    "\n",
    "Podobne ako v bode 4.2., zase zadefinujeme tri modely: celý autoenkodér, iba enkodér a iba dekodér. Pri vytváraní modelu dekodéra dbajte na to, aby ste pridali všetky potrebné vrstvy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "autoencoder = # TODO: define autoencoder\n",
    "\n",
    "encoder = # TODO: define encoder\n",
    "\n",
    "encoded_input = # TODO: define input to decoder\n",
    "decoder_layer = # TODO: define next layer of the decoder\n",
    "decoder_layer = # TODO: define next layer of the decoder\n",
    "decoder_layer = # TODO: define next layer of the decoder\n",
    "decoder = # TODO: define decoder"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. 3. Trénovanie autoenkodéra\n",
    "\n",
    "V ďalšom kroku natrénujeme hlboký autoenkodér rovnako ako v bode 4.3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "autoencoder.compile(# TODO: insert parameters: optimizer, loss\n",
    "    )\n",
    "autoencoder.fit(# TODO: insert parameters: input, output, epochs, batch_size, shuffle\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. 4. Testovanie autoenkodéra\n",
    "\n",
    "Vizualizácia bude mať rovnaký tvar ako v bode 4.4. V tomto bode ale pre ukážku nepoužijeme autoenkodér, ale zvlášť enkodér a následne dekodér. Môžete dostať výsledok napr.:\n",
    "\n",
    "![](resources/lab09/autoencoder-deep.jpg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "encoded_imgs = encoder.predict(x_test)\n",
    "decoded_imgs = decoder.predict(encoded_imgs)\n",
    "\n",
    "plot_results(x_test, encoded_imgs, decoded_imgs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. Autoenkodér s konvolúciou\n",
    "\n",
    "Predošlé siete obsahovali iba tradičné plne prepojené vrstvy, v tomto kroku zadefinujeme a natrénujeme autoenkodér s konvolučnými vrstvami a pritom si vysvetlíme, ako funguje *upsampling* (opak *pooling*u). Kostru riešenia nájdete [na tomto odkaze](resources/lab09/lab09_conv.py)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6. 1. Načítanie potrebných knižníc\n",
    "\n",
    "Novinkou medzi použitými modulmi a triedami je vrstva `UpSampling2D`, ktorý slúži na \"dekonvolúciu\", teda o rozšírenie rozmerov obrazu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from keras.layers import Input, Conv2D, MaxPooling2D, UpSampling2D\n",
    "from keras.models import Model\n",
    "from keras.datasets import mnist\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.2. Vizualizácia výsledkov\n",
    "\n",
    "Aj v tomto prípade chceme otestovať fungovanie nášho autoenkodéra a porovnať rekonštruovaný obraz s originálom. Na tento účel sme zadefinovali zjednodušnú funkciu `plot_results`, ktorý zobrazí ukážkové vstupy a výstupy autoenkodéra (odstránili sme vizualizáciu zakódovaného tvaru)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def plot_results(x_test, decoded_imgs, n=10):\n",
    "    plt.figure(figsize=(40, 4))\n",
    "    for i in range(n):\n",
    "        # display original\n",
    "        ax = plt.subplot(3, n, i + 1)\n",
    "        plt.imshow(x_test[i].reshape(28, 28))\n",
    "        plt.gray()\n",
    "        ax.get_xaxis().set_visible(False)\n",
    "        ax.get_yaxis().set_visible(False)\n",
    "\n",
    "        # display reconstruction\n",
    "        ax = plt.subplot(3, n, i + 1 + n * 2)\n",
    "        plt.imshow(decoded_imgs[i].reshape(28, 28))\n",
    "        plt.gray()\n",
    "        ax.get_xaxis().set_visible(False)\n",
    "        ax.get_yaxis().set_visible(False)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6. 3. Príprava údajov\n",
    "\n",
    "Ďalším krokom v riešení je úprava údajov z datasetu MNIST tak, aby sme ich vedeli použiť pre našu sieť. Vykonáme tie isté kroky, ako v predošlých úlohách, teda hodnoty najprv pretypujeme na *float* a normalizujeme ich na interval 0 až 1. Labely z datasetu stále nepotrebujeme, použijeme iba vstupné hodnoty.\n",
    "\n",
    "Ďalej potrebujeme trénovaciu aj testovaciu množinu upraviť do tvaru, s ktorým vie naša sieť pracovať. Keďže samotný dataset už obsahuje fotky s rozmerom *28x28*, nepotrebujeme vykonať veľké zmeny, dataset iba rozšíreme o jednu dimenziu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x_train = # TODO: make type float32, normalize to interval 0 to 1\n",
    "x_test = # TODO: make type float32, normalize to interval 0 to 1\n",
    "x_train = # TODO: reshape\n",
    "x_test = # TODO: reshape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.4. Definícia autoenkodéra\n",
    "\n",
    "V ďalšom kroku zadefinujeme náš autoenkodér. Vstupná vrstva je definovaná trénovacou množinou, ale okrem toho môžete navrhnúť ľubovoľnú topológiu. Kostra riešenia je ale napísaná pre nasledujúcu štruktúru, s kernelom *3x3*:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "_________________________________________________________________\n",
    "Layer (type)                 Output Shape              Param #   \n",
    "_________________________________________________________________\n",
    "input_1 (InputLayer)         (None, 28, 28, 1)         0         \n",
    "_________________________________________________________________\n",
    "conv2d_1 (Conv2D)            (None, 28, 28, 16)        160       \n",
    "_________________________________________________________________\n",
    "max_pooling2d_1 (MaxPooling2 (None, 14, 14, 16)        0         \n",
    "_________________________________________________________________\n",
    "conv2d_2 (Conv2D)            (None, 14, 14, 8)         1160      \n",
    "_________________________________________________________________\n",
    "max_pooling2d_2 (MaxPooling2 (None, 7, 7, 8)           0         \n",
    "_________________________________________________________________\n",
    "conv2d_3 (Conv2D)            (None, 7, 7, 8)           584       \n",
    "_________________________________________________________________\n",
    "max_pooling2d_3 (MaxPooling2 (None, 4, 4, 8)           0         \n",
    "_________________________________________________________________\n",
    "conv2d_4 (Conv2D)            (None, 4, 4, 8)           584       \n",
    "_________________________________________________________________\n",
    "up_sampling2d_1 (UpSampling2 (None, 8, 8, 8)           0         \n",
    "_________________________________________________________________\n",
    "conv2d_5 (Conv2D)            (None, 8, 8, 8)           584       \n",
    "_________________________________________________________________\n",
    "up_sampling2d_2 (UpSampling2 (None, 16, 16, 8)         0         \n",
    "_________________________________________________________________\n",
    "conv2d_6 (Conv2D)            (None, 14, 14, 16)        1168      \n",
    "_________________________________________________________________\n",
    "up_sampling2d_3 (UpSampling2 (None, 28, 28, 16)        0         \n",
    "_________________________________________________________________\n",
    "conv2d_7 (Conv2D)            (None, 28, 28, 1)         145       \n",
    "_________________________________________________________________\n",
    "Total params: 4,385\n",
    "Trainable params: 4,385\n",
    "Non-trainable params: 0\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "input_img = # define input layer\n",
    "\n",
    "encoded_1 = # define first convolution, activation relu, padding same\n",
    "encoded_2 = # define max pooling layer, padding same\n",
    "encoded_3 = # define second convolution, activation relu, padding same\n",
    "encoded_4 = # define max pooling layer, padding same\n",
    "encoded_5 = # define third convolution, activation relu, padding same\n",
    "encoded = # define max pooling layer, padding same\n",
    "\n",
    "decoded_1 = # define first decoding convolution, activation relu, padding same\n",
    "decoded_2 = # define first upsampling layer\n",
    "decoded_3 = # define second decoding convolution, activation relu, padding same\n",
    "decoded_4 = # define second upsampling layer\n",
    "decoded_5 = # define third decoding convolution, activation relu\n",
    "decoded_6 = # define third upsampling layer\n",
    "decoded = # define final decoding convolution, activation sigmoid, padding same\n",
    "\n",
    "autoencoder = Model(input_img, decoded)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.5. Trénovanie a testovanie modelu\n",
    "\n",
    "Keď už máme sieť zadefinovanú, neostáva nám nič iné ako sieť natrénovať a otestovať. Keďže trénovanie môže trvať dlhší čas, našu sieť otestujeme po každej epoche, práve preto zadefinujeme cyklus, ktorý v každej iterácii vykoná iba jednu epochu a následne zobrazí ukážkové vstupy a výstupy pomocou volania funkciue `plot_results`.\n",
    "\n",
    "Vo funkcii `fit` nastavte nasledujúce parametre:\n",
    "* `input` - vstup autoenkodéra\n",
    "* `output` - očakávaný výstup autoenkodéra\n",
    "* `epochs` - 1\n",
    "* `batch_size` - napr. 128\n",
    "* `shuffle` - nastavte na True pre náhodné poradie v trénovacej množine\n",
    "* `verbose` - nastavte na 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "autoencoder.compile(# optimizer adadelta, loss function binary_crossentropy\n",
    "    )\n",
    "\n",
    "EPOCH_NO = 25\n",
    "for x in range(EPOCH_NO):\n",
    "    autoencoder.fit(# define parameters\n",
    "        )\n",
    "\n",
    "    decoded_imgs = autoencoder.predict(x_test)\n",
    "\n",
    "    plot_results(x_test, decoded_imgs)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}