manifold_and_latent.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Автоэнкодеры в Keras\n",
    "\n",
    "# Часть 2: Manifold learning и скрытые (*latent*) переменные"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Содержание\n",
    "\n",
    "* Часть 1: Введение\n",
    "* ** Часть 2: *Manifold learning* и скрытые (*latent*) переменные **\n",
    "* Часть 3: Вариационные автоэнкодеры (*VAE*)\n",
    "* Часть 4: *Conditional VAE*\n",
    "* Часть 5: *GAN* (Generative Adversarial Networks) и tensorflow\n",
    "* Часть 6: *VAE* + *GAN*\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для того, чтобы лучше понимать как работают автоэнкодеры, а так же чтобы в последствии генерировать из кодов что-то новое, стоит разобраться в том, что такое коды и как их можно интерпретировать."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Manifold learning"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Наши изображения цифр это элементы 28*28=784-мерного пространства, как и вообще любое монохромное изображение 28 на 28.\n",
    "Однако среди всех изображений, изображения цифр занимают лишь ничтожную часть, абсолютное же большинство изображений это просто шум. \n",
    "С другой стороны, если вязть произвольное изображение цифры, то и все изображения из некоторой окрестности так же можно считать цифрой. \n",
    "Если взять два произвольных изображения цифры, то в изначальном 784-мерном пространстве скорее всего можно найти непрерывную кривую, все точки вдоль которой можно так же считать цифрами (хотя бы изображений цифр одного лейбла), а вкупе с прерыдущим замечанием, то и все точки некоторой области вдоль этой кривой.\n",
    "\n",
    "Таким образом в пространстве всех изображений есть некоторое подпространство меньшей размерности в области вокруг которого сосредоточились изображения цифр. То есть, если наша генеральная совокупность это все изображения цифр, которые могут быть нарисованы впринципе, то плотность вероятности встретить такую цифру в пределах области сильно выше, чем вне."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Автоэнкодеры с размерностью кода k ищут k-мерное многообразие в пространстве объектов, которое наиболее полно передает все вариации в выборке. А сам код задает параметризацию этого многообразия. При этом энкодер сопоставляет объекту его параметр на многообразии, а декодер параметру сопоставляет точку в пространстве объектов."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Чем больше размерность кодов, тем больше вариаций в данных автоэнкодер сможет передать. Если размерность кодов слишком мала, автоэнкодер запомнит нечто среднее по недостающим вариациям в заданной метрике (это одна из причин, почему *mnist* цифры все более размытые при снижении размерности кода в автоэнкодерах)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для того, чтобы лучше понять что такое ***manifold learning***, создадим простой двумерный датасет в виде кривой плюс шум и будем обучать на нем автоэнкодер"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Импорт необходимых библиотек\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import seaborn as sns\n",
    "\n",
    "# Создание датасета\n",
    "x1 = np.linspace(-2.2, 2.2, 1000)\n",
    "fx = np.sin(x1)\n",
    "dots = np.vstack([x1, fx]).T\n",
    "noise = 0.06 * np.random.randn(*dots.shape)\n",
    "dots += noise\n",
    "\n",
    "# Цветные точки для отдельной визуализации позже\n",
    "from itertools import cycle\n",
    "size = 25\n",
    "colors = [\"r\", \"g\", \"c\", \"y\", \"m\"]\n",
    "idxs = range(0, x1.shape[0], x1.shape[0]//size)\n",
    "vx1 = x1[idxs]\n",
    "vdots = dots[idxs]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Визуализация: (скрыто)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Визуализация\n",
    "plt.figure(figsize=(12, 10))\n",
    "plt.xlim([-2.5, 2.5])\n",
    "plt.scatter(dots[:, 0], dots[:, 1])\n",
    "plt.plot(x1, fx,  color=\"red\", linewidth=4)\n",
    "plt.grid(False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](figs2/1d_manifold.png)\n",
    "На картинке выше синие точки - данные, а красная кривая - многообразие определяющее наши данные"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Линейный сжимающий автоэнкодер"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Самый простой автоэнкодер - это двухслойный сжимающий автоэнкодер с линейными функциями активации (больше слоев не имеет смысла при линейной активации).\n",
    "\n",
    "Такой автоэнкодер ищет аффинное (линейное со сдвигом) подпространство в пространстве объектов, которое описывает наибольшую вариацию в объектах, тоже самое делает и ***PCA*** (метод главных компонент) и оба они находят одно и тоже подпространство"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "from keras.layers import Input, Dense\n",
    "from keras.models import Model\n",
    "from keras.optimizers import Adam\n",
    "\n",
    "def linear_ae():\n",
    "    input_dots = Input((2,))\n",
    "    code = Dense(1, activation='linear')(input_dots)\n",
    "    out  = Dense(2, activation='linear')(code)\n",
    "\n",
    "    ae = Model(input_dots, out)\n",
    "    return ae\n",
    "\n",
    "ae = linear_ae()\n",
    "ae.compile(Adam(0.01), 'mse')\n",
    "\n",
    "ae.fit(dots, dots, epochs=15, batch_size=30, verbose=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Применение линейного автоэнкодера\n",
    "pdots = ae.predict(dots, batch_size=30)\n",
    "vpdots = pdots[idxs]\n",
    "\n",
    "# Применения PCA\n",
    "from sklearn.decomposition import PCA\n",
    "pca = PCA(1)\n",
    "pdots_pca = pca.inverse_transform(pca.fit_transform(dots))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Визуализация: (скрыто)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Визуализация\n",
    "plt.figure(figsize=(12, 10))\n",
    "plt.xlim([-2.5, 2.5])\n",
    "plt.scatter(dots[:, 0], dots[:, 1], zorder=1)\n",
    "plt.plot(x1, fx,  color=\"red\", linewidth=4, zorder=10)\n",
    "plt.plot(pdots[:,0], pdots[:,1], color='white', linewidth=12, zorder=3)\n",
    "plt.plot(pdots_pca[:,0], pdots_pca[:,1], color='orange', linewidth=4, zorder=4)\n",
    "plt.scatter(vpdots[:,0], vpdots[:,1], color=colors*5, marker='*', s=150, zorder=5)\n",
    "plt.scatter(vdots[:,0], vdots[:,1], color=colors*5, s=150, zorder=6)\n",
    "plt.grid(False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](figs2/ae_pca.png)\n",
    "\n",
    "На картинке выше:\n",
    "* белая линия - многообразие в которое переходят синие точки данных после автоэнкодера,\n",
    "то есть попытка автоэнкодера построить многообразие, определяющее больше всего вариации в данных\n",
    "* оранжевая линия - многообразие в которое переходят синие точки данных после PCA\n",
    "* разноцветные кружки - точки, которые переходят в зведочки соответствующего цвета после автоэнкодера\n",
    "* разноцветные звездочки - соответственно образы кружков после автоэнкодера"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Автоэнкодер ищущий линейные зависимости может быть не так полезен, как автоэнкодер, который может находить произвольные зависимости в данных. Полезно было бы, если и энкодер и декодер могли аппроксимизировать произвольные функции. Если добавить и в энкодер и в декодер еще хотя бы по одному слою достаточного размера и нелинейную функцию активации между ними, то они смогут находить произвольные зависимости"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Глубокий автоэнкодер"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "У глубокого автоэнкодера больше число слоев и самое главное - нелинейная функция активации между ними (в нашем случае *ELU* - Exponential Linear Unit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Код: (скрыто)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def deep_ae():\n",
    "    input_dots = Input((2,))\n",
    "    x = Dense(64, activation='elu')(input_dots)\n",
    "    x = Dense(64, activation='elu')(x)\n",
    "    code = Dense(1, activation='linear')(x)\n",
    "    x = Dense(64, activation='elu')(code)\n",
    "    x = Dense(64, activation='elu')(x)\n",
    "    out = Dense(2, activation='linear')(x)\n",
    "\n",
    "    ae = Model(input_dots, out)\n",
    "    return ae\n",
    "\n",
    "dae = deep_ae()\n",
    "dae.compile(Adam(0.003), 'mse')\n",
    "\n",
    "dae.fit(dots, dots, epochs=200, batch_size=30, verbose=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "pdots_d = dae.predict(dots, batch_size=30)\n",
    "vpdots_d = pdots_d[idxs]\n",
    "\n",
    "# Визуализация\n",
    "plt.figure(figsize=(12, 10))\n",
    "plt.xlim([-2.5, 2.5])\n",
    "plt.scatter(dots[:, 0], dots[:, 1], zorder=1)\n",
    "plt.plot(x1, fx,  color=\"red\", linewidth=4, zorder=10)\n",
    "plt.plot(pdots_d[:,0], pdots_d[:,1], color='white', linewidth=12, zorder=3)\n",
    "plt.plot(pdots_pca[:,0], pdots_pca[:,1], color='orange', linewidth=4, zorder=4)\n",
    "plt.scatter(vpdots_d[:,0], vpdots_d[:,1], color=colors*5, marker='*', s=150, zorder=5)\n",
    "plt.scatter(vdots[:,0], vdots[:,1], color=colors*5, s=150, zorder=6)\n",
    "plt.grid(False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](figs2/dae_pca.png)\n",
    "\n",
    "У такого автоэнкодера практически идеально получилось построить определяющее многообразие:\n",
    "белая кривая почти совпадает с красной"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Глубокий автоэнкодер теоретически сможет найти многообразие произвольной сложности, например такое, около которого лежат цифры в 784-мерном пространстве"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если взять два объекта и посмотреть на объекты лежащие на произвольной кривой между ними, то скорее всего промежуточные объекты не будут принадлежать генеральной совокупности, т. к. многообразие на котором лежит генеральная совокупность может быть сильно искривленным и малоразмерным"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Вернемся к датасету рукописных цифр из предыдущей части:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Код: (скрыто)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from keras.layers import Conv2D, MaxPooling2D, UpSampling2D\n",
    "from keras.datasets import mnist\n",
    "\n",
    "(x_train, y_train), (x_test, y_test) = mnist.load_data()\n",
    "\n",
    "x_train = x_train.astype('float32') / 255.\n",
    "x_test  = x_test .astype('float32') / 255.\n",
    "x_train = np.reshape(x_train, (len(x_train), 28, 28, 1))\n",
    "x_test  = np.reshape(x_test,  (len(x_test),  28, 28, 1))\n",
    "\n",
    "\n",
    "# Сверточный автоэнкодер\n",
    "def create_deep_conv_ae():\n",
    "    input_img = Input(shape=(28, 28, 1))\n",
    "\n",
    "    x = Conv2D(128, (7, 7), activation='relu', padding='same')(input_img)\n",
    "    x = MaxPooling2D((2, 2), padding='same')(x)\n",
    "    x = Conv2D(32, (2, 2), activation='relu', padding='same')(x)\n",
    "    x = MaxPooling2D((2, 2), padding='same')(x)\n",
    "    encoded = Conv2D(1, (7, 7), activation='relu', padding='same')(x)\n",
    "\n",
    "    # На этом моменте представление  (7, 7, 1) т.е. 49-размерное\n",
    "\n",
    "    input_encoded = Input(shape=(7, 7, 1))\n",
    "    x = Conv2D(32, (7, 7), activation='relu', padding='same')(input_encoded)\n",
    "    x = UpSampling2D((2, 2))(x)\n",
    "    x = Conv2D(128, (2, 2), activation='relu', padding='same')(x)\n",
    "    x = UpSampling2D((2, 2))(x)\n",
    "    decoded = Conv2D(1, (7, 7), activation='sigmoid', padding='same')(x)\n",
    "\n",
    "    # Модели\n",
    "    encoder = Model(input_img, encoded, name=\"encoder\")\n",
    "    decoder = Model(input_encoded, decoded, name=\"decoder\")\n",
    "    autoencoder = Model(input_img, decoder(encoder(input_img)), name=\"autoencoder\")\n",
    "    return encoder, decoder, autoencoder\n",
    "\n",
    "c_encoder, c_decoder, c_autoencoder = create_deep_conv_ae()\n",
    "c_autoencoder.compile(optimizer='adam', loss='binary_crossentropy')\n",
    "c_autoencoder.fit(x_train, x_train,\n",
    "                epochs=50,\n",
    "                batch_size=256,\n",
    "                shuffle=True,\n",
    "                validation_data=(x_test, x_test))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def plot_digits(*args):\n",
    "    args = [x.squeeze() for x in args]\n",
    "    n = min([x.shape[0] for x in args])\n",
    "    \n",
    "    plt.figure(figsize=(2*n, 2*len(args)))\n",
    "    for j in range(n):\n",
    "        for i in range(len(args)):\n",
    "            ax = plt.subplot(len(args), n, i*n + j + 1)\n",
    "            plt.imshow(args[i][j])\n",
    "            plt.gray()\n",
    "            ax.get_xaxis().set_visible(False)\n",
    "            ax.get_yaxis().set_visible(False)\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "# Гомотопия по прямой в пространстве объектов или в пространстве кодов\n",
    "def plot_homotopy(frm, to, n=10, decoder=None):\n",
    "    z = np.zeros(([n] + list(frm.shape)))\n",
    "    for i, t in enumerate(np.linspace(0., 1., n)):\n",
    "        z[i] = frm * (1-t) + to * t\n",
    "    if decoder:\n",
    "        plot_digits(decoder.predict(z, batch_size=n))\n",
    "    else:\n",
    "        plot_digits(z)\n",
    "\n",
    "\n",
    "frm, to = x_test[y_test == 8][1:3]\n",
    "plot_homotopy(frm, to)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](figs2/homotopy_x.png)\n",
    "Если же двигаться по кривой между кодами (и если многообразие кодов хорошо параметризовано), то декодер переведет эту кривую из пространства кодов, в кривую не покидающую определяющее многообразие в пространстве объектов. То есть промежуточные объекты на кривой будут принадлежать генеральной совокупности"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "codes = c_encoder.predict(x_test[y_test == 8][1:3])\n",
    "plot_homotopy(codes[0], codes[1], n=10, decoder=c_decoder)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](figs2/homotopy_z.png)\n",
    "Промежуточные цифры - вполне себе хорошие восьмерки"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Таким образом можно сказать, что автоэнкодер, по крайней мере локально, выучил форму определяющего многообразия"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Переобучение автоэнкодера"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для того, чтобы автоэнкодер мог научиться вычлинять какие-то сложные закономерности, обобщающие способности энкодера и декодера должны быть ограничены, иначе даже автоэнкодер с одномерным кодом сможет просто провести одномерную кривую через каждую точку в обучающей выборке, т.е. просто запомнить каждый объект. Но это сложное многообразие, которое построит автоэнкодер не будет иметь много общего с определяющим генеральную совокупность многообразием\n",
    "\n",
    "Возьмем ту же задачу с искуственными данными, обучим тот же глубокий автоэнкодер на очень маленьком подмножестве точек и посмотрим на получившееся многообразие"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "dae = deep_ae()\n",
    "dae.compile(Adam(0.0003), 'mse')\n",
    "x_train_oft = np.vstack([dots[idxs]]*4000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "dae.fit(x_train_oft, x_train_oft, epochs=200, batch_size=15, verbose=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "pdots_d = dae.predict(dots, batch_size=30)\n",
    "vpdots_d = pdots_d[idxs]\n",
    "\n",
    "plt.figure(figsize=(12, 10))\n",
    "plt.xlim([-2.5, 2.5])\n",
    "plt.scatter(dots[:, 0], dots[:, 1], zorder=1)\n",
    "plt.plot(x1, fx,  color=\"red\", linewidth=4, zorder=10)\n",
    "plt.plot(pdots_d[:,0], pdots_d[:,1], color='white', linewidth=6, zorder=3)\n",
    "plt.plot(pdots_pca[:,0], pdots_pca[:,1], color='orange', linewidth=4, zorder=4)\n",
    "plt.scatter(vpdots_d[:,0], vpdots_d[:,1], color=colors*5, marker='*', s=150, zorder=5)\n",
    "plt.scatter(vdots[:,0], vdots[:,1], color=colors*5, s=150, zorder=6)\n",
    "plt.grid(False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](figs2/overfitted_ae.png)\n",
    "Видно, что белая кривая прошла через каждую точку данных и слабо похожа на определяющую данные красную кривую: на лицо типичное переобучение"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Скрытые переменные "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Можно рассмотреть генеральную совокупность как некоторый процесс генерации данных $X$, который зависит от некоторого количества скрытых переменных $Z$ (случайных величин). Размерность данных $X$ может быть намного выше, чем размерность скрытых случайных величин $Z$, которые эти данные определяют. Рассмотрим процесс генерации очередной цифры:\n",
    "то, как будет выглядеть цифра, может зависеть от множества факторов:\n",
    "- желаемой цифры,\n",
    "- толщины штриха,\n",
    "- наклона цифры,\n",
    "- аккуратности,\n",
    "- и т.д.\n",
    "\n",
    "Каждый из этих факторов имеет свое априорное распределение, например вероятность того, что будет нарисована восьмерка это распределение Бернулли с вероятностью 1/10, толщина штриха тоже имеет некоторое свое распределение и может зависеть как от аккуратности, так и от своих скрытых переменных, таких как толщина ручки или темперамент человека (опять же со своими распределениями)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Автоэнкодер сам в процессе обучения должен прийти к скрытым факторам, например таким как перечисленые выше,\n",
    "каким-то их сложным комбинациям, или вообще к совсем другим. Однако, то совместное расределение, которое он выучит\n",
    "вовсе не обязано быть простым, это может быть какая-то сложная кривая область. (Декодеру можно передать и значения извне этой области, вот только результаты уже не будут из определяющего многообразия, а из его случайного непрерывного продолжения)\n",
    "\n",
    "Именно поэтому мы не можем просто генерировать новые $X$ из распределения этих скрытых переменных. Сложно оставаться\n",
    "в пределах области, а еще сложнее как-то интепретировать значения скрытых переменных в этой кривой области."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для определенности введем некоторые обозначения на примере цифр:\n",
    "- $X$ - случайная величина картинки 28х28,\n",
    "- $Z$ - случайная величина скрытых факторов, определяющих цифру на картинке, \n",
    "- $p(X)$ - вероятностное распределение изображений цифр на картинках, т.е. вероятность конкретного изображения цифры впринципе быть нарисованым (если картинка не похожа на цифру, то эта вероятность крайне мала),\n",
    "- $p(Z)$ - вероятностное распределение скрытых факторов, например, распределение толщины штриха,\n",
    "- $p(Z|X)$ - распределение вероятности скрытых факторов при заданной картинке (к одной и той же картинке могут привезти различное сочетание скрытых переменных и шума),\n",
    "- $p(X|Z)$ - распределение вероятности картинок при заданных скрытых факторах, одни и те же факторы могут привезти к разным картинкам (один и тот же человек в одних и тех же условиях не рисует абсолютно одинаковые цифры),\n",
    "- $p(X,Z)$ - совместное распределение $X$ и $Z$, наиболее полное понимание данных, необходимое для генерации новых объектов"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$p(X,Z) = p(X|Z) p(Z)$$\n",
    "$p(X|Z)$ нам приближает декодер, но p(Z) на данный момент мы пока еще не понимаем"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Посмотрим, как распределены скрытые переменные в обычном автоэнкодере"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Код: (скрыто)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from keras.layers import Flatten, Reshape\n",
    "from keras.regularizers import L1L2\n",
    "\n",
    "def create_deep_sparse_ae(lambda_l1):\n",
    "    # Размерность кодированного представления\n",
    "    encoding_dim = 16\n",
    "\n",
    "    # Энкодер\n",
    "    input_img = Input(shape=(28, 28, 1))\n",
    "    flat_img = Flatten()(input_img)\n",
    "    x = Dense(encoding_dim*4, activation='relu')(flat_img)\n",
    "    x = Dense(encoding_dim*3, activation='relu')(x)\n",
    "    x = Dense(encoding_dim*2, activation='relu')(x)\n",
    "    encoded = Dense(encoding_dim, activation='linear', activity_regularizer=L1L2(lambda_l1, 0))(x)\n",
    "    \n",
    "    # Декодер\n",
    "    input_encoded = Input(shape=(encoding_dim,))\n",
    "    x = Dense(encoding_dim*2, activation='relu')(input_encoded)\n",
    "    x = Dense(encoding_dim*3, activation='relu')(x)\n",
    "    x = Dense(encoding_dim*4, activation='relu')(x)\n",
    "    flat_decoded = Dense(28*28, activation='sigmoid')(x)\n",
    "    decoded = Reshape((28, 28, 1))(flat_decoded)\n",
    "    \n",
    "    # Модели\n",
    "    encoder = Model(input_img, encoded, name=\"encoder\")\n",
    "    decoder = Model(input_encoded, decoded, name=\"decoder\")\n",
    "    autoencoder = Model(input_img, decoder(encoder(input_img)), name=\"autoencoder\")\n",
    "    return encoder, decoder, autoencoder\n",
    "\n",
    "encoder, decoder, autoencoder = create_deep_sparse_ae(0.)\n",
    "autoencoder.compile(optimizer=Adam(0.0003), loss='binary_crossentropy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "autoencoder.fit(x_train, x_train,\n",
    "                epochs=100,\n",
    "                batch_size=64,\n",
    "                shuffle=True,\n",
    "                validation_data=(x_test, x_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "n = 10\n",
    "imgs = x_test[:n]\n",
    "decoded_imgs = autoencoder.predict(imgs, batch_size=n)\n",
    "\n",
    "plot_digits(imgs, decoded_imgs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Вот так выглядят восстановленные этим энкодером изображения: (скрыто)\n",
    "![](figs2/ae_im_comp.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Совместное распределение скрытых переменных $P(Z_1, Z_3)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "codes = encoder.predict(x_test)\n",
    "sns.jointplot(codes[:,1], codes[:,3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](figs2/ae_jointplot.png)\n",
    "Видно, что совместное распределение $p(Z_1,Z_3)$ имеет сложную форму; $Z_1$ и $Z_3$ зависимы друг от друга"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Есть ли какой-то способ контролировать распределения скрытых переменных P(Z)?\n",
    "\n",
    "Самый простой способ - добавить регуляризатор $L_1$ или $L_2$ на значения $Z$, это добавит априорные предположения на распределения скрытых переменных, соответственно лапласса или нормальное (похоже на априорное распределение добавляемое на значения весов при регуляризации). Регуляризатор вынуждает автоэнкодер искать скрытые переменные, которые распределены по нужным законам, получится ли у него - другой вопрос. Однако это никак не заставляет делать их независимыми, т.е. $p(Z_i) \\neq p(Z_i|Z_j) $"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Посмотрим на совместное распределение скрытых параметров в разреженом автоэнкодере"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Код и визуализация: (скрыто)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "s_encoder, s_decoder, s_autoencoder = create_deep_sparse_ae(0.00001)\n",
    "s_autoencoder.compile(optimizer=Adam(0.0003), loss='binary_crossentropy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "s_autoencoder.fit(x_train, x_train,\n",
    "                epochs=200,\n",
    "                batch_size=256,\n",
    "                shuffle=True,\n",
    "                validation_data=(x_test, x_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "imgs = x_test[:n]\n",
    "decoded_imgs = s_autoencoder.predict(imgs, batch_size=n)\n",
    "\n",
    "plot_digits(imgs, decoded_imgs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](figs2/sae_im_comp.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "codes = s_encoder.predict(x_test)\n",
    "snt.jointplot(codes[:,1], codes[:,3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "![](figs2/sae_jointplot.png)\n",
    "$Z_1$ и $Z_3$ все так же зависимы друг от друга, но теперь хотя бы распределены вокруг 0, и даже более-менее нормально"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "О том, как контролировать скрытое пространство, так, чтобы из него уже можно было осмысленно генерировать изображения - в следующей части про вариационные автоэнкодеры (VAE)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Полезные ссылки и литература"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Этот пост основан на главе про автоэнкодеры (в частности подглавы *Learning maifolds with autoencoders*) в *Deep Learning Book*:  \n",
    "http://www.deeplearningbook.org/contents/autoencoders.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.6.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}