neurocomputers-python/lab3/3.1_autoencoder.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "VhB5tU1IGSIh"
   },
   "source": [
    "### ЛАБОРАТОРНАЯ РАБОТА №3\n",
    "## Применение многослойного персептрона. Автоассоциативная ИНС"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "15BpjnZQzAUG"
   },
   "source": [
    "> Цель работы: знакомство с применением многослойного персептрона для решения задач сжатия данных, прогнозирования временных рядов и распознавания образов.\n",
    ">\n",
    "> Задание\n",
    "> 1. Открыть файл с данными по минеральной воде, который использовался при решении задач классификации в предыдущей лабораторной работе. Построить и обучить автоассоциативные нейронные сети с 2-мя и 3-мя нейронами в скрытом слое:  \n",
    "> а) для исходных данных из 5-ти классов;  \n",
    "> б) для исходных данных из 4-х классов.  \n",
    "> Провести визуализацию данных в скрытом слое каждой сети на плоскость и в 3-х мерное пространство.  Проанализировать полученные результаты. Выбрать и сохранить автоассоциативные ИНС, обеспечивающие наилучшее сжатие исходных данных.  \n",
    "> 2. …  \n",
    "> 3. Решить задачу распознавания 9-ти изображений самолетов. Исходные данные (файлы avia1.bmp, …, avia9.bmp) необходимо предварительно преобразовать в набор векторов со значениями признаков 0 или 1. Обученная нейронная сеть должна правильно определять модель самолета и его класс (истребитель/бомбардировщик). Принадлежность модели к определенному классу выбирается студентом самостоятельно."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "F1-sSuk2zAUI"
   },
   "source": [
    "Импорт библиотек:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "FwCw1KfEpbsm"
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import torch\n",
    "import matplotlib.pyplot as plt\n",
    "from IPython.display import clear_output\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "from torch import nn\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "GtZJ1mGmzAUL"
   },
   "source": [
    "### Содержание:  \n",
    "[1. Подготовка данных](#p_1)  \n",
    "[2. Автоассоциативная нейронная сеть на полных данных](#p_2)  \n",
    "[3. Автоассоциативная нейронная сеть на неполных данных](#p_3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "HZNHPPKUzAUM"
   },
   "source": [
    "## 1. Подготовка данных<a id=\"p_1\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "h2JqhwwrzAUN"
   },
   "source": [
    "Загрузим в датафрейм `data` данные о сорока образцах минеральной воды, хранящиеся в файле `min_water.txt`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 256
    },
    "id": "PkNWYbQCpsl_",
    "outputId": "1de6457f-9cc1-42a1-b4f1-2c13c5b66100"
   },
   "outputs": [],
   "source": [
    "data = pd.read_csv('min_water.csv')\n",
    "data.head(n=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "YjqpAWl9zAUR"
   },
   "source": [
    "Вынесем в отдельные переменные:\n",
    " - `y_binary` — выходной признак для задачи бинарной классификации (первый столбец датафрейма);\n",
    " - `y_multiclass` — выходной признак для задачи многоклассовой классификации (второй столбец датафрейма);\n",
    " - `X_data` — входные признаки (оставшиеся столбцы)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "D_QiYrPkpsu0"
   },
   "outputs": [],
   "source": [
    "y_binary = data.iloc[:, 0]\n",
    "y_multiclass = data.iloc[:, 1]\n",
    "\n",
    "X_data = data.iloc[:, 2:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "rpgOkJkPzAUT"
   },
   "source": [
    "Выпишите в список `features` отобранные в прошлой лабораторной работе признаки (формат: `features = ['VAR1', 'VAR2']`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "R0bIf4PUzAUT"
   },
   "outputs": [],
   "source": [
    "features = # Ваш код здесь"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ddwgNPoyzAUV"
   },
   "source": [
    "Датафрейм с отобранными входными признаками `X_data_filtered`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 206
    },
    "id": "d6eTUCk2Cjdc",
    "outputId": "656c9a35-26f6-4425-b35e-ca06930abc82"
   },
   "outputs": [],
   "source": [
    "X_data_filtered = X_data.loc[:, features]\n",
    "X_data_filtered.head(n=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "C помощью функции `train_test_split` разбейте данные (`X_data_filtered`, `y_multiclass`) на обучающую (`X_multiclass_train`, `y_multiclass_train`), валидационную (`X_multiclass_valid`, `y_multiclass_valid`) и тестовую выборки (`X_multiclass_test`, `y_multiclass_test`) с сохранением соотншений классов (сортов минеральной воды):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "HclxngwAGue-"
   },
   "outputs": [],
   "source": [
    "X_multiclass_train, X_multiclass_test, y_multiclass_train, y_multiclass_test = # Ваш код здесь\n",
    "\n",
    "X_multiclass_train, X_multiclass_valid, y_multiclass_train, y_multiclass_valid = # Ваш код здесь"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "LAOh4V56zAUV"
   },
   "source": [
    "Произведите нормализацию или стандартизацию (на выбор) входных данных. Результат сохраните в переменные (`X_multiclass_train`, `X_multiclass_valid`, `X_multiclass_test`), которую затем представьте в виде тензоров:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_means = # Ваш код здесь\n",
    "X_stds = # Ваш код здесь\n",
    "\n",
    "X_multiclass_train = # Ваш код здесь\n",
    "X_multiclass_valid = # Ваш код здесь\n",
    "X_multiclass_test = # Ваш код здесь"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "AtGktiZmJiUV",
    "outputId": "f9edb4f0-c5ab-4a62-af28-6552c981512f"
   },
   "source": [
    "## 2. Автоассоциативная нейронная сеть на полных данных<a id=\"p_2\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jsWiE7Ke1p9S"
   },
   "source": [
    "Автоассоциативная сеть (или автоассоциативная память) — тип нейронной сети, способный восстанавливать полный шаблон данных по его частичному или зашумлённому представлению.\n",
    "\n",
    "Типичная автоассоциативная сеть содержит как минимум три скрытых слоя:\n",
    " - первый скрытый слой выполняет нелинейное кодирование входных данных (энкодер);\n",
    " - средний слой («узкое горло» или «бутылочное горло») формирует сжатое представление данных — в результате обучения выдаёт компактное кодирование;\n",
    " - последний скрытый слой служит декодером: восстанавливает исходные данные из сжатого представления.\n",
    "\n",
    "Цель обучения: в процессе минимизации ошибки воспроизведения сеть стремится сделать выходной сигнал максимально близким к входному. Это эквивалентно оптимальному кодированию в «узком горле» сети."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "asRgUuyNzAUY"
   },
   "source": [
    "Допишите класс `Autoencoder` структурами энкодера и декодера на основе полносвязных слоёв `nn.Linear`. В качестве функций активации используйте `nn.ReLU()`. При этом на выходе энкодера функцию активации можно не применять — это позволит сохранить отрицательные значения в кодированном представлении."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "F297Z81wzAUY"
   },
   "outputs": [],
   "source": [
    "class Autoencoder(nn.Module):\n",
    "    def __init__(self, n_inputs, n_hiddens, bottleneck_size):\n",
    "        super().__init__()\n",
    "        self.encoder = nn.Sequential(\n",
    "            # Ваш код здесь\n",
    "        )\n",
    "        self.decoder = nn.Sequential(\n",
    "            # Ваш код здесь\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        encoded = self.encoder(x)\n",
    "        decoded = self.decoder(encoded)\n",
    "        return decoded"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "R5sVUOy7zAUZ"
   },
   "source": [
    "Создайте экземпляр модели с двумя нейронами в «узком горле»:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "MlSSzk2yzAUa"
   },
   "outputs": [],
   "source": [
    "model_2 = Autoencoder(# Ващ код здесь\n",
    "print(model_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "tGS2_TqjK_SI",
    "outputId": "a1a63c33-5dd5-461e-8d20-97fc34455f21"
   },
   "source": [
    "Пропустим данные через эту модель для её проверки:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Y3GS-3AaKYt7",
    "outputId": "81ecb257-7d72-443e-aa9e-256271a17a6e"
   },
   "outputs": [],
   "source": [
    "model_2(X_multiclass_train[:3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8hJk8GWIzAUb"
   },
   "source": [
    "Удостоверимся, что размерность её выхода совпадает с размерностью её входа:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "pDmdGMRZzAUc"
   },
   "outputs": [],
   "source": [
    "assert X_multiclass_train[:3].shape == model_2(X_multiclass_train[:3]).shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "IjoYYn-ozAUc"
   },
   "source": [
    "Проверим, как модель обучается. Зададим оптимизатор и среднеквадратическую функцию потерь:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "VGWgT-_UKY5S"
   },
   "outputs": [],
   "source": [
    "optimizer = torch.optim.SGD(model_2.parameters(), lr=1.5)\n",
    "criterion = nn.MSELoss()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "HqcQqxN7zAUd"
   },
   "source": [
    "Рассчитаем значение функции потерь:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "5kKYW89_KY8j",
    "outputId": "a5ece716-5c89-4553-c78c-1e5c7e20eedf"
   },
   "outputs": [],
   "source": [
    "decoded = model_2(X_multiclass_train)\n",
    "\n",
    "loss = criterion(decoded, X_multiclass_train)\n",
    "loss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "JVplv7O8zAUd"
   },
   "source": [
    "Выполните несколько раз эту и предыдущую ячейку, чтобы убедиться в уменьшении ошибки:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "G_JCVLCkKZCa"
   },
   "outputs": [],
   "source": [
    "loss.backward()\n",
    "optimizer.step()\n",
    "optimizer.zero_grad()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "iXqI-DurzAUe"
   },
   "source": [
    "Задайте параметры для обучения автоассоциативной сети с двумя нейронами в «узком горле»:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "5s4GjW_PzAUe"
   },
   "outputs": [],
   "source": [
    "torch.manual_seed(seed=42)\n",
    "\n",
    "model_2 = # Ваш код здесь\n",
    "\n",
    "epochs = # Ваш код здесь\n",
    "\n",
    "learning_rate = # Ваш код здесь\n",
    "momentum = # Ваш код здесь\n",
    "\n",
    "optimizer = # Ваш код здесь\n",
    "criterion = # Ваш код здесь"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "SN8PZ41vzAUp"
   },
   "source": [
    "**Обучение нейронной сети:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "loss_train_history, loss_valid_history = [], []\n",
    "\n",
    "for epoch in range(epochs):\n",
    "    # Ваш код здесь\n",
    "\n",
    "    # Отключаем градиенты для этапа валидации\n",
    "    with torch.no_grad():\n",
    "        # Ваш код здесь\n",
    "\n",
    "    if (epoch + 1) % 5 == 0:\n",
    "\n",
    "        clear_output(True)\n",
    "        plt.plot(range(1, epoch+2), loss_train_history, label='Train', color='green')\n",
    "        plt.plot(range(1, epoch+2), loss_valid_history, label='Valid', color='red')\n",
    "        plt.title(f'Epoch: {epoch + 1}, Loss Train: {loss_train_history[-1]:.6f}, Loss Valid: {loss_valid_history[-1]:.6f}')\n",
    "        plt.grid(True, alpha=0.3)\n",
    "        plt.legend(loc='best')\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Проверим качество обученной сети на тестовой выборке:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "t-Xkwg4h3gyS",
    "outputId": "ddfc13ae-f942-4328-9036-92b318c726bc"
   },
   "outputs": [],
   "source": [
    "with torch.no_grad():\n",
    "    decoded_test = model_2(X_multiclass_test)\n",
    "    loss_test = criterion(decoded_test, X_multiclass_test)\n",
    "\n",
    "print(f'Loss Test: {loss_test.item():.6f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Далее необходимо через обученную сети пропустить все имеющиеся входные данные. Здесь можно сконкатенировать обучающую, валидационную и тестовую выборки, но можно и заново стандартизировать исходные данные `X_data_filtered` с помощью переменных `X_means` и `X_stds`, которые обязательно должны быть ранее рассчитаны на обучающей выборке `X_multiclass_train` (аналогично будет и для нормировки данных). Результат будет прелставлен в виде тензора.\n",
    "\n",
    "Такой вариант сохранит исходный порядок записей в данных и позволит нам использовать исходный вектор `y_multiclass` для разметки классов ниже."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "0RbKOwMeZUcn"
   },
   "outputs": [],
   "source": [
    "X_data_tensor = torch.tensor(((X_data_filtered - X_means) / X_stds).values).float()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "TrWOUf0vzAUq"
   },
   "source": [
    "После обучения сети получим двумерные данные с выхода энкодера:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "HFcSAdGoOaog",
    "outputId": "1233f17c-2188-402e-d1dc-697dc6c0bfb4"
   },
   "outputs": [],
   "source": [
    "encoded_2d = model_2.encoder(X_data_tensor).detach().numpy()\n",
    "print(encoded_2d[:3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "GjtM4NXLzAUr"
   },
   "source": [
    "Построим двумерную диаграмму рассеяния и отметим классы с помощью `y_multiclass`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 430
    },
    "id": "KkToPCInQQ1J",
    "outputId": "8469b911-292a-4016-fbd3-38f92997adad"
   },
   "outputs": [],
   "source": [
    "scatter = plt.scatter(x=encoded_2d[:, 0], y=encoded_2d[:, 1], c=y_multiclass, cmap='viridis')\n",
    "plt.grid(True, alpha=0.3)\n",
    "\n",
    "# Код для легенды\n",
    "handles, labels = scatter.legend_elements(prop='colors')\n",
    "plt.legend(handles, labels, loc='best', title='Classes')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "t0EmzLHXzAUs"
   },
   "source": [
    "По аналогии обучите автоассоциативную сеть с тремя нейронами в «узком горле»:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "WasLielLzAUt"
   },
   "outputs": [],
   "source": [
    "torch.manual_seed(seed=42)\n",
    "\n",
    "model_3 = # Ваш код здесь\n",
    "\n",
    "# Ваш код здесь"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "cFxc9xD-zAUt"
   },
   "outputs": [],
   "source": [
    "# Ваш код здесь"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "18f786y5zAUv"
   },
   "source": [
    "После обучения сети получите трёхмерные данные с выхода энкодера (снова по всем данным `X_data_tensor`, которые уже были подготовлены выше):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "PLjKuu-szAUw"
   },
   "outputs": [],
   "source": [
    "encoded_3d = # Ваш код здесь"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "BYn45sTnzAUx"
   },
   "source": [
    "Построим трёхмерную диаграмму рассеяния:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 653
    },
    "id": "RpqVg5EeT72I",
    "outputId": "7b9aac3c-68d5-44d7-db56-8f7a53e3aa37"
   },
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=(10, 8))\n",
    "ax = fig.add_subplot(111, projection='3d')\n",
    "\n",
    "scatter = ax.scatter(\n",
    "    xs=encoded_3d[:, 0],\n",
    "    ys=encoded_3d[:, 1],\n",
    "    zs=encoded_3d[:, 2],\n",
    "    c=y_multiclass,\n",
    "    cmap='viridis',\n",
    "    s=50\n",
    ")\n",
    "\n",
    "ax.grid(True, alpha=0.3)\n",
    "\n",
    "handles, labels = scatter.legend_elements(prop='colors', alpha=0.8)\n",
    "ax.legend(handles, labels, loc='best', title='Classes')\n",
    "\n",
    "# Настраиваем угол обзора:\n",
    "# elev — высота, azim — азимут\n",
    "ax.view_init(elev=20, azim=45)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "NNWL9ZakzAUy"
   },
   "source": [
    "Сохраним в бинарные файлы `.npy` выходы энкодеров обеих моделей — для следующей лабораторной работы:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "p2Zx-Jz4zAUz"
   },
   "outputs": [],
   "source": [
    "np.save('encoded_2d.npy', encoded_2d)\n",
    "np.save('encoded_3d.npy', encoded_3d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "K-pYtaxBzAUz"
   },
   "source": [
    "## 3. Автоассоциативная нейронная сеть на неполных данных<a id=\"p_3\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "J3RSV5WDzAU0"
   },
   "source": [
    "Выберите класс, который нужно исключить:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "_UuEf5TRzAU0"
   },
   "outputs": [],
   "source": [
    "label_to_exclude = # Ваш код здесь"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "MmlBKShgzAU1"
   },
   "source": [
    "Создадим маску для исключения данных этого класса:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "WwlU6wRqXy3H"
   },
   "outputs": [],
   "source": [
    "mask_to_exclude = y_multiclass != label_to_exclude"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "SA3A39ARzAU1"
   },
   "source": [
    "Данные исключены:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "I7sTKdWgQRWQ"
   },
   "outputs": [],
   "source": [
    "X_data_include = X_data_filtered.loc[mask_to_exclude, :]\n",
    "y_include = y_multiclass[mask_to_exclude]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "По аналогии с помощью функции `train_test_split` разбейте данные (`X_data_include`, `y_include`) на обучающую (`X_include_train`, `y_include_train`), валидационную (`X_include_valid`, `y_include_valid`) и тестовую выборки (`X_include_test`, `y_include_test`) с сохранением соотншений классов:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_include_train, X_include_test, y_include_train, y_include_test = # Ваш код здесь\n",
    "\n",
    "X_include_train, X_include_valid, y_include_train, y_include_valid = # Ваш код здесь"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Обратите внимание, что `X_means` и `X_stds` перерасчитываются уже на другой по составу обучающей выборке."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_means = # Ваш код здесь\n",
    "X_stds = # Ваш код здесь\n",
    "\n",
    "X_include_train = # Ваш код здесь\n",
    "X_include_valid = # Ваш код здесь\n",
    "X_include_test = # Ваш код здесь"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "V2MUFTkczAU2"
   },
   "source": [
    "По аналогии с предыдущим пунктом реализуйте обучение автоассоциативных сетей с двумя и тремя нейронами в «узком горле».\n",
    "\n",
    "Результаты выходов энкодеров в обоих случаях также сохраните в отдельные бинарные файлы."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "qnSnyqNGzAU2"
   },
   "outputs": [],
   "source": [
    "# Ваш код здесь"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "MMW6h5P1zAU3"
   },
   "outputs": [],
   "source": [
    "# Ваш код здесь"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Обратите внимание, что тензор `X_data_tensor` снова получен из исходных данных `X_data_filtered`, но уже с пересчитанными `X_means` и `X_stds` (без одного класса):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "1FjpRmrCaOp4"
   },
   "outputs": [],
   "source": [
    "X_data_tensor = torch.tensor(((X_data_filtered - X_means) / X_stds).values).float()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "encoded_2d_include = # Ваш код здесь"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "w3kJHSW3azk0"
   },
   "outputs": [],
   "source": [
    "# Ваш код здесь"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ваш код здесь"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "encoded_3d_include = # Ваш код здесь"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.save('encoded_2d_include.npy', encoded_2d_include)\n",
    "np.save('encoded_3d_include.npy', encoded_3d_include)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-BXig37czAU6"
   },
   "source": [
    "### Литература:\n",
    "1. Бородкин А.А., Елисеев В.Л. Основы и применение искусственных нейронных сетей. Сборник лабораторных работ: методическое пособие. – М.: Издательский дом МЭИ, 2017.\n",
    "2. MachineLearning.ru  —  профессиональный информационно-аналитический ресурс, посвященный машинному обучению, распознаванию образов и интеллектуальному анализу данных: http://www.machinelearning.ru\n",
    "3. Modern State of Artificial Intelligence  —  Online Masters program at MIPT: https://girafe.ai/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-KIqZEHczAU6"
   },
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "provenance": []
  },
  "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": 1
}