application_task.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Вступительное задание, направление Глубокое Обучение"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В рамках этого задания нужно:\n",
    "- установить основные библиотеки для глубокого обучения\n",
    "- скачать датасет CIFAR10\n",
    "- собрать свою собственную нейронную сеть \n",
    "- обучить эту сеть на CIFAR10 и измерить качество на тестовой выборке"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Настройка репозитория"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для того, чтобы успешно выполнить это задание, а также подготовиться к выполнению семинарских и домашних заданий нужно настроить [репозиторий курса](https://github.com/data-mining-in-action/DMIA_DL_2019_Spring). В README.md репозитория подробно описано, как это сделать.\n",
    "\n",
    "### Задание 1\n",
    "Чтобы удостовериться, что пакеты установлены правильно нужно выполнить следующий код:\n",
    "```\n",
    "out_pip_list = !pip list\n",
    "for package_info in out_pip_list:\n",
    "    if package_info.startswith('tensorflow'):\n",
    "        print(package_info)\n",
    "    if package_info.startswith('Keras '):\n",
    "        print(package_info)\n",
    "```\n",
    "\n",
    "Версии пакетов в выводе кода будут ответом на пункт 1 этого задания. Их нужно записать в форму в формате: \n",
    "```\n",
    "keras:n.n.n,tensorflow:n.nn.n\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-16T13:34:40.905004Z",
     "start_time": "2019-01-16T13:34:40.900785Z"
    }
   },
   "source": [
    "## Скачивание CIFAR10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 2\n",
    "Существует множество способов скачать [CIFAR10](https://en.wikipedia.org/wiki/CIFAR-10), но мы воспользуемся, вероятно, самым простым из них, а именно воспользуемся функциональностью библиотеки [keras](https://keras.io) (которую только что установили). Чтобы все сделать правильно, нужно выполнить следующие действия:\n",
    "- воспользоваться функцией load_data модуля keras.datasets.cifar10, можно использовать следующие названия переменных: (x_train, y_train), (x_test, y_test)\n",
    "- выполнить команду ```x_train.shape[0] + y_train.shape[0]```, вывод которой будет ответом на пункт 2 этого задания"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-16T15:57:41.585370Z",
     "start_time": "2019-01-16T15:57:40.491417Z"
    }
   },
   "outputs": [],
   "source": [
    "import keras\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "from numpy.random import seed\n",
    "from tensorflow import set_random_seed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "seed(1)\n",
    "set_random_seed(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(x_train, y_train), (x_test, y_test) = #код для загрузки CIFAR10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Посмотрим на картинки из CIFAR10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class_names = {0: 'airplane', 1: 'automobile', 2: 'bird', 3: 'cat', 4: 'deer',\n",
    "               5: 'dog', 6: 'frog', 7: 'horse', 8: 'ship', 9: 'truck'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-16T15:57:42.017320Z",
     "start_time": "2019-01-16T15:57:41.733318Z"
    }
   },
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=(8,3))\n",
    "\n",
    "for i in range(len(class_names)):\n",
    "    ax = fig.add_subplot(2, 5, 1 + i, xticks=[], yticks=[])\n",
    "    ax.set_title(class_names[i])\n",
    "    idx = np.where(y_train[:]==i)[0][0]\n",
    "    image = x_train[idx]\n",
    "    plt.imshow(image)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Создание модели в keras"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Из всего множества архитектур сверточных нейронных сетей мы соберем одну очень простую и прямолинейную. Чтобы выполнить задание, нужно вписать код в специально отведенные места. Получившийся ответ нужно вписать в форму ответа на пункт 3 этого задания."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-16T15:57:42.185439Z",
     "start_time": "2019-01-16T15:57:42.021901Z"
    }
   },
   "outputs": [],
   "source": [
    "from IPython.display import SVG\n",
    "from sklearn.metrics import accuracy_score\n",
    "from keras.utils.vis_utils import model_to_dot\n",
    "from keras.models import Sequential\n",
    "from keras.layers import (Dense, Conv2D, Activation,\n",
    "                          Dropout, MaxPooling2D, Flatten)\n",
    "from keras.optimizers import Adam\n",
    "from keras.utils import to_categorical"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В клетке ниже нужно создать объект класса Sequential из модуля keras.models и добавить в него блоки, тем самым собрав сверточную нейронную сеть, который мы будем классифицировать картинки из CIFAR10.\n",
    "\n",
    "Сеть должна иметь следующую структуру:\n",
    "```\n",
    "- Conv2D(filters=32, kernel_size=(3, 3), padding='same', input_shape=x_train.shape[1:]))\n",
    "- Activation(activation='relu')\n",
    "- Conv2D(filters=32, kernel_size=(3, 3), padding='same')\n",
    "- Activation(activation='relu')\n",
    "- MaxPooling2D(pool_size=(2, 2))\n",
    "- Dropout(rate=0.25)\n",
    "- Conv2D(filters=64, kernel_size=(3, 3), padding='same')\n",
    "- Activation(activation='relu')\n",
    "- Conv2D(filters=64, kernel_size=(3, 3), padding='same')\n",
    "- Activation(activation='relu')\n",
    "- MaxPooling2D(pool_size=(2, 2))\n",
    "- Dropout(rate=0.25)\n",
    "- Flatten()\n",
    "- Dense(units=128)\n",
    "- Activation(activation='relu')\n",
    "- Dropout(rate=0.5)\n",
    "- Dense(units=10)\n",
    "- Activation(activation='softmax', name='out')\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-16T15:57:42.206680Z",
     "start_time": "2019-01-16T15:57:42.200306Z"
    }
   },
   "outputs": [],
   "source": [
    "def create_model():\n",
    "    ##########################################\n",
    "    created_model = # код для создания объекта класса Sequential из модуля keras.models\n",
    "    ##########################################\n",
    "    return created_model\n",
    "\n",
    "def add_blocks_to_model(created_model):\n",
    "    \n",
    "    created_model.add(Conv2D(filters=32,\n",
    "                         kernel_size=(3, 3),\n",
    "                         padding='same',\n",
    "                         input_shape=x_train.shape[1:]))\n",
    "    created_model.add(Activation('relu'))\n",
    "    \n",
    "    ##########################################\n",
    "    # код для добавления блоков из списка выше\n",
    "    ##########################################\n",
    "    \n",
    "    created_model.add(Flatten())\n",
    "    created_model.add(Dense(units=128))\n",
    "    created_model.add(Activation('relu'))\n",
    "    created_model.add(Dropout(0.5))\n",
    "    created_model.add(Dense(units=10))\n",
    "    created_model.add(Activation('softmax', name='out'))\n",
    "    \n",
    "    return created_model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-16T15:57:42.212370Z",
     "start_time": "2019-01-16T15:57:42.207823Z"
    }
   },
   "outputs": [],
   "source": [
    "model = create_model()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-16T15:57:42.317134Z",
     "start_time": "2019-01-16T15:57:42.213535Z"
    }
   },
   "outputs": [],
   "source": [
    "model = add_blocks_to_model(model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Посмотрим на количество параметров модели и на размеры входов и выходов слоев."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-16T15:57:42.322260Z",
     "start_time": "2019-01-16T15:57:42.318493Z"
    }
   },
   "outputs": [],
   "source": [
    "model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Нарисуем модель."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-16T15:57:42.406956Z",
     "start_time": "2019-01-16T15:57:42.323467Z"
    }
   },
   "outputs": [],
   "source": [
    "SVG(model_to_dot(model).create(prog='dot', format='svg'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 3\n",
    "В ответе к заданию 3 нужно привести число, которое получится, если из числа нейронов во Flatten() блоке (это число нужно взять из результата команды `model.summary()` выше) вычесть количество классов, которые мы распознаем в этом задании."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Обучение модели в keras"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Чтобы обучить модель в keras, сначала ее нужно скомпиллировать. Мы скомпиллируем модель следующим образом:\n",
    "- модель должна использовать оптимизатор, который определен в первой строчке клетки ниже\n",
    "- функцией потерь для обучения должна быть 'categorical_crossentropy'\n",
    "- метрикой, которая нас интересует - accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-16T15:57:42.466614Z",
     "start_time": "2019-01-16T15:57:42.409425Z"
    }
   },
   "outputs": [],
   "source": [
    "opt = Adam(lr=0.0001)\n",
    "\n",
    "##########################################\n",
    "# код для компиляции модели\n",
    "##########################################"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-16T16:00:06.722864Z",
     "start_time": "2019-01-16T15:57:42.468523Z"
    }
   },
   "outputs": [],
   "source": [
    "history = model.fit(\n",
    "    x=x_train/255.,\n",
    "    y=to_categorical(y_train, num_classes=10),\n",
    "    batch_size=32,\n",
    "    epochs=10,\n",
    "    validation_data=(x_test/255., to_categorical(y_test, num_classes=10)),\n",
    "    shuffle=True\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-16T16:00:13.387142Z",
     "start_time": "2019-01-16T16:00:06.731382Z"
    }
   },
   "outputs": [],
   "source": [
    "preds_dl_train = model.predict(x_train/255., verbose=1, batch_size=64)\n",
    "preds_dl_test = model.predict(x_test/255., verbose=1, batch_size=64)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 4\n",
    "В ответе к заданию 4 нужно привести число, которое получится, если вывести результат сравнения test accuracy > train accuracy и взять int() от этого результата."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-16T16:00:13.414187Z",
     "start_time": "2019-01-16T16:00:13.395361Z"
    }
   },
   "outputs": [],
   "source": [
    "print('CNN train accuracy')\n",
    "train_acc = accuracy_score(y_train.flatten(),\n",
    "                           np.argmax(preds_dl_train, axis=1))\n",
    "print(train_acc)\n",
    "print('')\n",
    "print('CNN test accuracy')\n",
    "test_acc = accuracy_score(y_test.flatten(),\n",
    "                          np.argmax(preds_dl_test, axis=1))\n",
    "print(test_acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6.6"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}