2022/seminars/seminar11_pytorch/sem11_intro_to_pytorch.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Семинар 11: знакомство с PyTorch\n",
    "\n",
    "## Вступление\n",
    "\n",
    "В этом семинаре мы познакомимся с библиотекой **PyTorch**. Он очень похож на **NumPy**, с одним лишь отличием (на самом деле их больше, но сейчас мы поговорим про самое главное) — **PyTorch** может считать градиенты за вас. Таким образом вам не надо будет руками писать обратный проход в нейросетях.\n",
    "\n",
    "### План семинара:\n",
    "\n",
    "1. Вспоминаем **NumPy** и сравниваем операции его функциональность с **PyTorch**\n",
    "2. Создаем тензоры в **PyTorch** и изучаем больше базовых операций\n",
    "3. Работаем с градиентами руками\n",
    "4. Моя первая нейросеть"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn.functional as F\n",
    "import torchvision\n",
    "\n",
    "from sklearn.datasets import load_boston\n",
    "from torch import nn\n",
    "from tqdm.notebook import tqdm\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Вспоминаем **NumPy** и сравниваем операции его функциональность с **PyTorch**\n",
    "\n",
    "Мы можем создавать матрицы, перемножать их, складывать, транспонировать и в целом совершать любые матричные операции"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.72371593, 0.50921163, 0.53207512],\n",
       "       [0.59185616, 0.06783602, 0.79668999],\n",
       "       [0.23071615, 0.85677191, 0.88322301],\n",
       "       [0.00117589, 0.20947956, 0.10361602],\n",
       "       [0.07037212, 0.39856408, 0.32074193]])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# случайная матрица\n",
    "a = np.random.rand(5, 3)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5, 3)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# размеры массива\n",
    "a.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[5.72371593, 5.50921163, 5.53207512],\n",
       "       [5.59185616, 5.06783602, 5.79668999],\n",
       "       [5.23071615, 5.85677191, 5.88322301],\n",
       "       [5.00117589, 5.20947956, 5.10361602],\n",
       "       [5.07037212, 5.39856408, 5.32074193]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# сложение\n",
    "a + 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.06616517, 0.88677754, 1.07319217, 0.16265195, 0.42454169],\n",
       "       [0.88677754, 0.98961038, 0.8983257 , 0.09745607, 0.32421906],\n",
       "       [1.07319217, 0.8983257 , 1.56737093, 0.27126356, 0.64100114],\n",
       "       [0.16265195, 0.09745607, 0.27126356, 0.05461935, 0.11680778],\n",
       "       [0.42454169, 0.32421906, 0.64100114, 0.11680778, 0.26668094]])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# матричное умножение\n",
    "a @ a.T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.58833423, 0.48546072, 0.65690369, 0.10475716, 0.26322604])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# среднее по колонкам\n",
    "a.mean(axis=-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 5)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# решейп\n",
    "a.reshape(3, 5).shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Разминка\n",
    "\n",
    "При помощи **NumPy** посчитайте сумму квадратов натуральных чисел от 1 до 10000."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# YOUR CODE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Аналогичные операции в **PyTorch** очень похожи, но иногда имеют немного другой синтаксис"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.6434, 0.5560, 0.9995],\n",
       "        [0.6742, 0.4094, 0.2381],\n",
       "        [0.1748, 0.9996, 0.2559],\n",
       "        [0.3835, 0.3061, 0.0520],\n",
       "        [0.4834, 0.4109, 0.7033]])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# случайный тензор\n",
    "x = torch.rand(5, 3)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([5, 3])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# размеры тензора\n",
    "x.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([5, 3])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# тоже размеры тензора\n",
    "x.size()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[5.6434, 5.5560, 5.9995],\n",
       "        [5.6742, 5.4094, 5.2381],\n",
       "        [5.1748, 5.9996, 5.2559],\n",
       "        [5.3835, 5.3061, 5.0520],\n",
       "        [5.4834, 5.4109, 5.7033]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# сложение\n",
    "x + 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[1.7220, 0.8994, 0.9240, 0.4689, 1.2423],\n",
       "        [0.8994, 0.6789, 0.5880, 0.3963, 0.6616],\n",
       "        [0.9240, 0.5880, 1.0952, 0.3863, 0.6752],\n",
       "        [0.4689, 0.3963, 0.3863, 0.2435, 0.3477],\n",
       "        [1.2423, 0.6616, 0.6752, 0.3477, 0.8971]])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# матричное умножение\n",
    "# читайте документации по различным вариантам: @, torch.mm, torch.matmul, torch.bmm\n",
    "torch.matmul(x, x.transpose(1, 0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[1.7220, 0.8994, 0.9240, 0.4689, 1.2423],\n",
       "        [0.8994, 0.6789, 0.5880, 0.3963, 0.6616],\n",
       "        [0.9240, 0.5880, 1.0952, 0.3863, 0.6752],\n",
       "        [0.4689, 0.3963, 0.3863, 0.2435, 0.3477],\n",
       "        [1.2423, 0.6616, 0.6752, 0.3477, 0.8971]])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# очередное матричное умножение\n",
    "x.mm(x.t())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.4139, 0.3091, 0.9990],\n",
       "        [0.4546, 0.1676, 0.0567],\n",
       "        [0.0305, 0.9991, 0.0655],\n",
       "        [0.1471, 0.0937, 0.0027],\n",
       "        [0.2336, 0.1688, 0.4946]])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# поэлементное умножение\n",
    "x * x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([0.7329, 0.4406, 0.4768, 0.2472, 0.5325])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# среднее по колонкам\n",
    "x.mean(dim=-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([3, 5])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# решейп\n",
    "x.view([3, 5]).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([3, 5])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# или так\n",
    "x.reshape([3, 5]).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ True, False, False, False, False],\n",
       "        [False, False,  True, False, False],\n",
       "        [False, False, False, False,  True]])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# будьте внимательны и не используйте view для транспонирования осей!\n",
    "x.view_as(x.t()) == x.t()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Небольшой пример того, как меняются операции:\n",
    "\n",
    "* `x.reshape([1,2,8]) -> x.view(1,2,8)`\n",
    "\n",
    "* `x.sum(axis=-1) -> x.sum(dim=-1)`\n",
    "\n",
    "* `x.astype(\"int64\") -> x.type(torch.LongTensor)`\n",
    "\n",
    "Для помощи вам есть [таблица](https://github.com/torch/torch7/wiki/Torch-for-Numpy-users), которая поможет вам найти аналог **NumPy** операции в **PyTorch**\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Разминка на pytorch\n",
    "\n",
    "При помощи pytorch посчитайте сумму квадратов натуральных чисел от 1 до 10000."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# YOUR CODE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Создаем тензоры в **PyTorch** и изучаем больше базовых операций"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 0.0000e+00,  8.5899e+09, -7.1972e-22],\n",
       "        [-1.5849e+29,  4.0820e-01,  2.3811e-01],\n",
       "        [ 1.7478e-01,  9.9955e-01,  2.5595e-01],\n",
       "        [ 3.8351e-01,  3.0615e-01,  5.1960e-02],\n",
       "        [ 4.8336e-01,  4.1085e-01,  7.0329e-01]])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# пустой тензор\n",
    "x = torch.empty(5, 3)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.4556, 0.1991, 0.6200],\n",
       "        [0.8642, 0.7365, 0.0043],\n",
       "        [0.7536, 0.5995, 0.1648],\n",
       "        [0.1977, 0.4866, 0.6791],\n",
       "        [0.6985, 0.7993, 0.4026]])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# случайный тензор ~ Uniform[0, 1)\n",
    "x = torch.rand(5, 3)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0., 0., 0.],\n",
       "        [0., 0., 0.],\n",
       "        [0., 0., 0.],\n",
       "        [0., 0., 0.],\n",
       "        [0., 0., 0.]])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# тензор с нулями и указанием типов чисел\n",
    "x = torch.zeros(5, 3, dtype=torch.float32)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([5.5000, 3.0000])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# конструируем тензор из питоновского листа\n",
    "x = torch.tensor([5.5, 3])\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[1., 1., 1.],\n",
       "        [1., 1., 1.],\n",
       "        [1., 1., 1.],\n",
       "        [1., 1., 1.],\n",
       "        [1., 1., 1.]], dtype=torch.float64)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# используем уже созданный тензор для создания тензора из единичек\n",
    "x1 = x.new_ones(5, 3, dtype=torch.double)\n",
    "x1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[-0.7354, -0.6773, -0.6208],\n",
       "        [ 1.0887, -0.6210, -0.2496],\n",
       "        [-0.2903,  0.6845, -0.2467],\n",
       "        [-0.5339,  1.0453,  0.7056],\n",
       "        [ 1.1824, -0.7675,  0.6351]])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# создаем случайный тензор с размерами другого тензора\n",
    "x = torch.randn_like(x1, dtype=torch.float)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = torch.rand(5, 3)\n",
    "y = torch.rand(5, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.3257, 0.4406, 0.9101],\n",
       "        [0.1317, 0.3773, 0.5120],\n",
       "        [0.2251, 0.0270, 0.8007],\n",
       "        [0.8002, 0.0747, 0.5570],\n",
       "        [0.4509, 0.8987, 0.3707]])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.1281, 0.8518, 0.0160],\n",
       "        [0.1804, 0.8616, 0.3345],\n",
       "        [0.2624, 0.2885, 0.5581],\n",
       "        [0.2135, 0.8258, 0.0699],\n",
       "        [0.5051, 0.4147, 0.5347]])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.4538, 1.2924, 0.9262],\n",
       "        [0.3121, 1.2389, 0.8465],\n",
       "        [0.4875, 0.3155, 1.3587],\n",
       "        [1.0137, 0.9005, 0.6269],\n",
       "        [0.9560, 1.3134, 0.9055]])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# сложение\n",
    "x + y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.4538, 1.2924, 0.9262],\n",
       "        [0.3121, 1.2389, 0.8465],\n",
       "        [0.4875, 0.3155, 1.3587],\n",
       "        [1.0137, 0.9005, 0.6269],\n",
       "        [0.9560, 1.3134, 0.9055]])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# очередное сложение\n",
    "z = torch.add(x, y)\n",
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.4538, 1.2924, 0.9262],\n",
       "        [0.3121, 1.2389, 0.8465],\n",
       "        [0.4875, 0.3155, 1.3587],\n",
       "        [1.0137, 0.9005, 0.6269],\n",
       "        [0.9560, 1.3134, 0.9055]])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# наконец, ещё одно сложение!\n",
    "torch.add(x, y, out=x)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 5, 3])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# добавили измерение в начало, аналог броадкастинга\n",
    "x.unsqueeze(0).size()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 5, 3])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# убрали одно единичное измерение\n",
    "x.unsqueeze(0).unsqueeze(1).squeeze(0).size()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([5, 3])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# убрали все единичные измерения\n",
    "x.unsqueeze(0).unsqueeze(1).squeeze().size()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([5, 3])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# операции без _ не меняют тензор, а создают копию\n",
    "x.unsqueeze(0)\n",
    "x.size()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 5, 3])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# операции с _ меняют тензор\n",
    "x.unsqueeze_(0)\n",
    "x.size()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Мы можем делать обычные срезы и переводить матрицы из **PyTorch** в **NumPy** и наоборот:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.ones((3, 5))\n",
    "x = torch.ones((3, 5))\n",
    "np.allclose(x.numpy(), a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.allclose(x.numpy()[:, 1], a[:, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[1., 1., 1., 1., 1.],\n",
       "        [1., 1., 1., 1., 1.],\n",
       "        [1., 1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.from_numpy(x.numpy())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Работаем с градиентами руками"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/anaconda3/envs/ml/lib/python3.9/site-packages/sklearn/utils/deprecation.py:87: FutureWarning: Function load_boston is deprecated; `load_boston` is deprecated in 1.0 and will be removed in 1.2.\n",
      "\n",
      "    The Boston housing prices dataset has an ethical problem. You can refer to\n",
      "    the documentation of this function for further details.\n",
      "\n",
      "    The scikit-learn maintainers therefore strongly discourage the use of this\n",
      "    dataset unless the purpose of the code is to study and educate about\n",
      "    ethical issues in data science and machine learning.\n",
      "\n",
      "    In this special case, you can fetch the dataset from the original\n",
      "    source::\n",
      "\n",
      "        import pandas as pd\n",
      "        import numpy as np\n",
      "\n",
      "\n",
      "        data_url = \"http://lib.stat.cmu.edu/datasets/boston\"\n",
      "        raw_df = pd.read_csv(data_url, sep=\"\\s+\", skiprows=22, header=None)\n",
      "        data = np.hstack([raw_df.values[::2, :], raw_df.values[1::2, :2]])\n",
      "        target = raw_df.values[1::2, 2]\n",
      "\n",
      "    Alternative datasets include the California housing dataset (i.e.\n",
      "    :func:`~sklearn.datasets.fetch_california_housing`) and the Ames housing\n",
      "    dataset. You can load the datasets as follows::\n",
      "\n",
      "        from sklearn.datasets import fetch_california_housing\n",
      "        housing = fetch_california_housing()\n",
      "\n",
      "    for the California housing dataset and::\n",
      "\n",
      "        from sklearn.datasets import fetch_openml\n",
      "        housing = fetch_openml(name=\"house_prices\", as_frame=True)\n",
      "\n",
      "    for the Ames housing dataset.\n",
      "    \n",
      "  warnings.warn(msg, category=FutureWarning)\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXAAAAD4CAYAAAD1jb0+AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAAsTAAALEwEAmpwYAAAtT0lEQVR4nO2df4wcZ5nnv8/0lO0eB9I2mc0lnRibXGSLnImHzIE5I4S9uzG7ITBLQkxkUP5A5O7EScSbm2NYobWDjBh2BMn+BcoeHD7Fm9jEYWLWJxmELXHru5jzMGOCl/gWNr9oQmLO7kAynbg989wf3dWuqX7fqreq63c/H8ma7p7uqqfK00899bzf53mImSEIgiDkj4G0DRAEQRDCIQ5cEAQhp4gDFwRByCniwAVBEHKKOHBBEIScMpjkzq666ipeu3ZtkrsUBEHIPTMzM79j5mH364k68LVr1+LUqVNJ7lIQBCH3ENHzqtclhSIIgpBTxIELgiDkFHHggiAIOUUcuCAIQk4RBy4IgpBTjFQoRPQcgD8AWABwiZlHiWg1gAMA1gJ4DsBdzHwhagOnZ2uYOnoWtXoDJSIsMKNaKWN8+3qMjVQ779v5d/8bJ351XmE78K+HV+Jfzs1jgRklItz93uuxd2wjpmdr2HP4DOqNJgBg1ZCF3bffBACYOnoWv6k3cK1iX2HsN92W7v1BtyMIQvEhk26EbQc+ysy/c7z2NwDOM/MkEU0AWMXMn/fazujoKAeREU7P1vCFJ55Go7nQ9buyVcJXPrYRYyNVrfP2YssNq/GTZy+gubj0+AcIKA0QmguXX3fuKwgq+722pXv/HbdUcWimZrwdQRCKBRHNMPOo+/VeUigfBbCv/XgfgLEetqVk6uhZpfMGgEZzAVNHzwJAYOdtf8btvAFgkbHEebv3FQSV/V7b0r3/0ZMvBtqOIAj9gakDZwA/IKIZIrq3/drVzPxS+/FvAVyt+iAR3UtEp4jo1Llz5wIZ95t6o6ffR0mYfek+E/T1Bc1dUpLHLwhC9jB14O9n5ncD+DMAnyWiDzh/ya08jNLLMPPDzDzKzKPDw12VoJ5cWyn39PsoCbMv3WeCvl4iiswmQRCKg5EDZ+Za++crAL4H4D0AXiaiawCg/fOVqI0b374eZauk/F3ZKmF8+3oArXx2ULbcsBrWQLdjHCDAKi193bmvIKjs99qW7v13v/f6QNsRBKE/8HXgRLSSiN5iPwZwK4CfAzgM4J722+4B8GTUxo2NVPGVj21EtR1p2pFotVJesoC3/zPv0zpxIuDGP1rZ+WyJCJ/cvAb7P/M+TH38ZlTKVue9q4YsfP2uTZi682ZUK2WQa1/TszVsmTyGdRNHsGXyGKZna8b2u7cV5P17xzYG2o4gCP2BrwqFiN6BVtQNtGSHf8/MXyaitwE4CGANgOfRkhF6riYGVaFESa8yvKCKEkEQhKjQqVCMZIRRkZYDVzlfArBz8xrsHdtotI0tk8dQUywaVitlnJjYFpWpgiAIXcQhI8wNKnkeA9j/1Au+aRCboMoRQRCEuOkLB65zsgwYa6mDKkcEQRDipi8cuJeTNY2ggypKBEEQ4qYvHPj49vVQK6nNI+igihJBEIS4SXSkWlqMjVRx6vnz2P/UC0uqjYJG0GMjVXHYgiBkhr6IwAFg79hGPLhjk0TQgiAUhr5x4NKOVRCEotEXKRS3DrxWb+ALTzwNAOLEBUHILX0RgQdt6yoIgpAHChWB69IkUoQjCEIRKYwD90qTXFspK8vgpQhHEIQ8U5gUileaZOuG4S4duBThCIKQdwrjwHXpkFq9gUMztSX6bwJwxy2i6RYEId8UxoF7TbNRNbI6/kyw8W6CIAhZozAOXNerRDdPslZvGA1lEARByCqFceC6XiVVj4VKe6FTnLggCHmkMCoUQN+rxD3MwYm90Cn5cEEQ8kahHLgK2zFPHT2rlBICogcXBCGfFM6BO4t5KkMWmIFXG01cWylj1ZCFC/PNrs+IHlwQhDxSKAfuLuZxOutavQFrgGCVCM2FywubogcXBCGvFGYRE1AX8zhpLjJWLhuUlrKCIBSCQkXguhy3k1cbTcztvjUBawRBEOKlUA68RKTVfdskle+W/uOCIMRNoRy4n/O2BiiRfLf0HxcEIQkKlQP3KtoBAO1k44iR/uOCICRBoRz4+Pb1sEp6L91c4EScqPQfFwQhCQrlwAEA3lmURJyoLs8uenNBEKKkUA586uhZNBfTX8TUNdYSvbkgCFGS20VMlcrDL7pOyok6y/dFhSIIQlwQ+yg3omR0dJRPnTrV83bcKg+g5ZyXDw6g3ugulQdaC5wqJypyP0EQsg4RzTDzqPv1XEbgOpXHCmsAZavU5dh11ZYi9xMEIc/kMgeuS5XU55vKnuA6ZyxyP0EQ8kwuI3CvKfO6nuAqRO4nCEKeyWUEHpXKQ+R+giDkmVw6cN34tKB5a5H7CYKQZ4xTKERUAnAKQI2ZP0xE6wA8BuBtAGYAfIqZL8ZjZjdBUiVe2wBE7icIQj4JkgP/HIBfAHhr+/lXATzIzI8R0TcBfBrANyK2L3aiuBD4IVJFQRDiwCiFQkTXAbgNwH9tPycA2wA83n7LPgBjMdiXe2ypYq3eAOOyVHF6tpa2aYIg5BzTHPhDAP4LgMX287cBqDPzpfbzXwNQhpREdC8RnSKiU+fOnevF1lwiUkVBEOLC14ET0YcBvMLMM2F2wMwPM/MoM48ODw+H2USuEamiIAhxYZID3wLgI0T05wBWoJUD/1sAFSIabEfh1wGQnIACL826IAhCL/hG4Mz8BWa+jpnXAvgEgGPMvBPAcQB3tt92D4AnY7MyYqZna9gyeQzrJo5gy+SxWPPRIlUUBCEuetGBfx7AXxLRL9HKiX8rGpPiJelFxag064IgCG5y2Y2wF7ZMHlOmNKqVMk5MbEvBIkEQBG8K1Y2wF3SLh7V6A1smj4lWWxCE3JDLUvpe0C0eEiBabUEQckXhHLjfAqVqUZHQPUpTtNqCIGSdQjlw1QLlrgNzWOtw5qpFRd0qQK3ekChcEITMUqgcuKrq0XbO7mk7zvy2bmETAMa/e7rzGUEQhCxRqAjcr7pRlxZRpVVsmouMPYfPRGKfIAhClBTKgZtUN6qcvJ1W0aEblCwIgpAmhXHg07M1vP7mJd/36Zx80imSJKtBBUEoJoXIgbuny+vwK2FfNWThwnx3tE2EzgKoiS1+vb/d9rrz82G2KQhC/1GICFy1eAkAlbIVqIR99+03wSpR1+vMMNKF+5Xp21H3fQfmjFvMSj9xQRB0FCIC1y1evtpoYm73rcbbsZ37/QdPY8HVYsB2sF4XAL/e3353Carj8NqmROGC0N8UwoH30rLVTk/U6g2UiLoctxM/lYtX72/dXYKfvdJPXBAEHYVIoYRt2epMTwDwdN6A/oJgp0Z0n762UvZ1uDp7dfuUfuKCIBTCgYdt2WoSFdvoHKz7IqD7nJfD9bJX+okLgqAjNykUPyWGyXR59zZ0TlfFCkt9rfO6CFRddrpz4GWr5HuhsX8nKhRBENzkwoEHld2ZbiMIF+abyn3qUiMELOkv3osjNrk4CYLQf+TCgUehxAiSLtGh2mdFox2vDFldr4kjFgQhSnKRA49CiRGVasO9Hd26Z4KDjgRB6FNyEYFHMdk9aM5b1SNctc9XNX1SdK+HRaoxBUFwk4sIPAolhmob1gApKy9XDVnYuXmN0T6TkPlJNaYgCCpyEYGbLACaqFRU2/Da7ujbV/tGvVs3DGP/Uy8sidajlvlJNaYgCCoKMZVe1cxKJ9H74vTTePTki1hgRokId7/3euwd22iconBWbqrSLARg5+Y12Dumb08blHUTR5TpHALw7ORtke1HEIRsUuip9KYR6henn8YjT73Qeb7AjEeeegGPPPXCEmeskym6LxQqp8oAjj9zztPeoPnsKNYABEEoHoVw4KYqlUdPvqjdhtdQY9vZDvj0SvGzBwinaR/fvl55hyHVmILQ3+RiEdMP04VEE+frxHau9uKh6ee9ImO/joUqwrYKEASh2BQiAtdFqFs3DGPL5LFOqoIomD67RBS4+McrMp6erWmljH46dSkCEgTBTSEcuO3Y9hw+05lfOUDAgZ+8iOZiy2PX6g0MkDpvraJslQI77wFaGk2r8uc6JJ8tCEJQCpFCsXnz0mLn8esXFzrO22aRgSFrACXq1n4DLVUHcDlFUfVxqvZ2KmULVolg706l0/Yq5Zd8tiAIYSiMAzftdTLfXMQiM6qVMj65ec2SvPKDOzbhucnbOk2ovIYkVytlfO2um1GtlFFvNNFcUE/wsfFKkUg+WxCEMBQihQIE63ViVzMemqnhKx9r6bWnjp7FrgNzmDp6Fls3DOPQTM0zYt66YTjQiDSdFLBaKYvzFgQhFIWJwMPkkBvNBXzhiZ9h14G5JWXqjzz1gmeP7698bCOOP3Mu0Ig0GcwgCELUFMaBK3udlAjqbPdlGs1F44VNu8f32Eg18Ii0tKSA9ri3dRNHsGXymPRPEYQCUZgUiq7Xya4Dc5HtwxlRe3U3dE/icdqYZLokikEYvexbuicKQrwUxoEDagdp9y3pFXdErdOeZ2lBMq0mWGleOAShnyhMCkWHKrUSlBJRl2OOOiUSR6ojikEYYQhTbSoIQnB8I3AiWgHgxwCWt9//ODPvJqJ1AB4D8DYAMwA+xcwX4zQ2DKrUSpCI3Cuqdkf8thN2pw380glxRaxpNcFK68IhCP2GbztZIiIAK5n5NSKyAPwjgM8B+EsATzDzY0T0TQCnmfkbXtuKq51sULZMHjNy4rpctgpVS1sC8O9uWI2fvvCqZ6pFZ0+1Ul4yGDkoOps44LEFJa7jEYR+RddO1jeFwi1eaz+12v8YwDYAj7df3wdgLBpTo0OXlhjfvt5XnWI7m16GJjOAE78675tOiCtidaZ5AChb5vqlasKkdkQyKQjJYJQDJ6ISEc0BeAXADwH8CkCdme1SxV8DUHo6IrqXiE4R0alz57z7ZEeJ1xiysZGqp3SQgE4jLFPHFdTZuot8VESR6hgbqeLExDZUK2XPlrkqwo5yk+6JgpAMRioUZl4AsImIKgC+B2CD6Q6Y+WEADwOtFEoIG0Php8BYNWThwrx68DADSyoxTXLSQXPrA0RYN3EE11bKysrPqCPWMFF+LyoW6Z4oCPETSIXCzHUAxwG8D0CFiOwLwHUAMlUh4uWwpmdreO0NfZ8TAIFVFCZpGScLzEtK+u+4pRprxBomypfFSEHINiYqlGEATWauE1EZwJ8C+CpajvxOtJQo9wB4Mk5Dg+KlwJg6erarU6EJtXoDWyaPaYch79y8pmvAsZuSYqpPo7mA48+c813g66U4JsxUHxnlJgjZxiSFcg2AfURUQitiP8jM/0BE/wTgMSLaC2AWwLditDMQ07M1zF/sjrBth9VLdWat3sD4d08DhE4Hwlq9gV0H5sBotZa1e5K7IQCLGtWPM6pVOWoAPUkNdZWqXp+VUW6CkG0KMZXeiUo6B7Qc656P3ISxkaqxjDAsqmn1NqoIHLisevGS/qmIW5onJfGCkD6FnkrvRNcXfOXywY7jUUWWUcLQO12V83ZGtTo5oo5e8tEmzlkWIwUhuxTOgZssvDnTCXFF4naxjG77JSIsMnc5zqAOOWw+WvqVCEL+KVwvFFO1hVMfHRRrgGCVvDUnJSJPZ7zIjGfb03+cDjOoQ56/eClU3xTpV9JC2u0KeaZwDjxoFWDQiLdaKWPq4zdj6s6bl1Q4urFlgjp0jjpo860L802j4ho3IhEMX6gkCFmhcCmUoGqLIAU4JaIl27J/OnPJA5pFSideF5Qw6Z0wLWL7TSKoyven1W5XEKKicCqUoKhUH1aJAIZSK+7X83vdxBHfMv2dm9dg79hGI/vWThwxeh8BeHbyNqP3Aurjzlo/86jQHatuETvouRSEuOkbFUpQbGf1wPfPdErrVy4bxIdvvgaPnnxRWXRzX3v4saqgp+JRog+0FjcfPfkiRt++2shRei2EOgkaOYfRhecVXaStk3QW9S5EKB5978Bt3mgudh7XG00cmql5pkJq9QbGHz+9JFKv1RudBU67yEfFAnOX4kMn6TORPIYtrulVIpgXjbgur7/A3BWJS6GSkCcKt4gZBq8IzYvmAnelWZqLjMEB8lW3OBUffp0Tv/KxjVpbVNOCkiBPC4C6iNruOSNdE4W8Ig4c/hFaUBrNRYxvX4+Hdmzy/Ly9Xz9J39hIVVuCv8icisPJkwzRS5lky0lVkk5ByDriwGEWoQXFVjJ4Rc/2fk0kfXH2DA9DnmSI0p9cKCqSA4d30yY7T6xTq+hy3bYjs52EV1MoE0lf1hpL5U2GKC0BhCIiETjMI7Tlg5dP16ohC1N33oxVQ5Zym05H5rd9k+KjrEWRMjZNENKn73XgOpwKi8qQhdfeuBS4h7h7cLCXasPrd1+cfnpJn/EkBhObkBcViiDkHZ0OvPAOPIyT0bWkDYNVIqxcNoh6o9nVodCkcOaL00/jkade0P4+K85cEIT46MtCnjAd96Zna7j/4GnfcnhTmgvcGfCgGyrs5XT3ezhv5zaT6iYoUbcgZIdCO/CgvS5shx+V8zZBp9qwHWUQS5zHppvq04vzNb0gipMXhGQotAMPKnV74PtnYhvyoEOl2uglhfObeqMrZ64bAxc0Yje5IEqfcUFIjkI78CBSt+nZmmcPkzggoBMZB+1oqOPKsqUcrKxagG00F3D/wdPYdWDOKFI2uSBKhz9BSI5CywiDSN3SqCBkYInG3C5LD+u8y1YJRN4j2NzYfctNSuFNionyVOAjRIcMxkiHQjtwU+309Gwt1iHHOggtlcn9B0+HSpesGrK6jq3ew12EXym8yQUxaxWjQvzkqS9O0Si8jNCPKCWDYfCaOG/6+SvLFoiA+nyzp/SLvT13L2w7vVOrN5bYu2rIwu7bb1qyaKq6EFolwtSdN0eWQjFdJJXF1GTYMnlM+f9erZRxYmJbChYVD52MsNARuAm6KfZJ0evlk9Fqf3thvmmUfikRgdo/ddtz3gI7oyu3vXYLXvd7lBuNCNNoT6LC5JC0WXr0vQNPI3WSJnbOe9mgfjCz09l5XeDslIvfRbC5yJGtMZh2QcxTt8S8I2mz9Ci0CsWP6dlazymMpFg+OIA3Ly36v9GQRnMRA2ilQVTqG3vykB+mUZaf3t00zaHbTq3ewLqJI51tSFSYHFlrtNZP9HUEHrRQJg0IwJYbVmMxYB8WExYBDC0bhPfYCm+urZSNIi0vvXuQNIfXvpzbqBg0GROiIWuN1vqJvo7A8xCNMYD/9avzsV1o7Mg3TCrJGWWNP35a21rXS7oZVDNuMmKu0VzA8sEBGZeWINKuNx362oGHdVxJE+ddAgOYv3gJ1gAZdVu0BwFXK2Vs3TCsVZ7YeDXZCpPmcA9j1ln8aqOJB3dsEhWKUGj62oGbRHP9wIX5JqwSGa0H/KsrV3SiWL9zp5OR+fV50aU53PnyB3dswp7DZzrNwtzbiDMqFImikAVEB67ROEdBXhZIbVYNWai35YheWAOEK1YMGrUeIGCJg/PT3eta7ConIg0QFgEsuO4crAHC1Mej0527Udli0hpYEMLSl+1kTXBGaV7FKGHYuXkNjvzspcR7rITlwnwTZWsAjaa32qW5yMbH5FxYBLx1917pFtXndCmfK1YMxupIpd+LkBX6WoXixp5Q7jXE2FSxsWrIwt6xjZj961vx0I5NoQYj98pDOzahbAX7L/Zz3mGxHZwuv02A51T4IAvOvbQTMEEkikJWEAeuQNXzAwAqZQs7N69ZIpfacsPqLqdOAG571zWd5yYXhjiYOnq2Uy2ZBex8sQo/eV8Q+V/cUkEpXBGygjhwBbau1T2wuN5o4tBMDePb1+PZydtwYmIb9n/mfdi5ec0SJ84ADs3UluiZp2drmL94KZkDaFPzcJhxoov6K0OW8hyYyPtUF1VrgFAaWHr5tEoUu1RQBjoLWUEcuIaxkSqGlnUvEajKsY8/c047Lg24vOiVdC68RC1n1kuhThgWGd3OtkR47Y1LXeeA6PK58irgURWL7HjP9d1/wAmsGkvhipAVfBcxieh6AP8dwNVofT0eZua/JaLVAA4AWAvgOQB3MfOF+ExNHtNcp9/70mqYtcCMsZGqUUl8lLx5aXHJRaNsDWD5YEkp97NFULV6A7sOzOG+A3PaxUy3LHDL5LGuhUy770rczjSMRFGkh0LUmETglwDcz8zvBLAZwGeJ6J0AJgD8iJlvBPCj9vNCYZrr9HtfWotb1Uq50+8laZxutdFcVDpv3WdMOwcmvZjYy9AC6Y4oxIGvA2fml5j5p+3HfwDwCwBVAB8FsK/9tn0AxmKyMTVMc51+70snD93afx76vaiwx72FnRAU9YSYXh2wdEcU4iBQDpyI1gIYAXASwNXM/FL7V79FK8Wi+sy9RHSKiE6dO3euF1sTxzTX6fc+naolrgWIElFn/1mStqnOgRcLzJ5OUnfh3LphOPJot1cHbHK3IGPJhKAYF/IQ0RUADgG4j5l/T46BAMzMRKQM9Jj5YQAPA61KzN7MTR7TXKfX+8ZGqjj1/PmuYcOlEoEXOPII+e73Xt+xJUv9Xt695srAjbmcTlKXP7aLr0pEaDQX8OjJF7sGW/RaaOPVxnZ6tua7Xb8B2+7qTmfxk+TJBR1GQSARWWg57/3M/ET75ZeJ6Jr2768B8Eo8JhYDlVKlucCoDFldUWSvOet/OP1S57Eu+k+DsF0V7QVOZ0S968Ac1k4cwdTRs9i6YRhlq9Rx2rqpRL3cjXilwUyie780m6RYhDD4OnBqhdrfAvALZv6641eHAdzTfnwPgCejN6846JxHfb7ZlX5x68qDUm80O7fgzvROUtz4RyuVr/dyp+H+rHPBc/9TLxipfHpZi/C6EJo4Wr80m1R3CmEwSaFsAfApAE8T0Vz7tb8CMAngIBF9GsDzAO6KxcKCcGXZUioxrixb2vTLI0+9EHp/7lvwsZGqdvhslHxy8xocfybZtQ6TC0OvhTb2/49OkmniaL3SbH4pFkFQYaJC+UdmJmZ+FzNvav/7H8z8/5j5j5n5Rmb+E2Y+n4TBeUUzQxi/f6OpvP3eO9ZdCRqURnMBD3z/TGdh7Pzrb/a0PRMOzdQyk3O3IQB33NJ7a9mxkar2TqZXRyvVnUIYpBIzIXQNlhZZn0ONoinThflmJ3ccdaMq1WT7RnNBO/E+Trz2yEBkdwVxOVqp7oyXoip8+r6dbFJ4qUF0CokkFST2hB2TtA0BeHDHJuzSpBMWmBPthW4NEHa853rP1r1R5ZLdE4GirKjM2liyolSOFlnhIxF4QvipQVQORvUZO9KMclHSLl03iVIJrT7nYyNV3wHDQQkdubc/5tV5UTfkOAx2d0m7oVnenYCKIlWOFlnhIxF4Qthf8vsPnlbK3FTO0C/a81uUtAYAv6yJs/DFT8lhO++9YxsBRDuSzp5oAwC7DswFugA0F1ip/XYS1eCpLEWlfrb0YmuRhlYUWeEjDjxB7D981TguXQ7V67baz4FescLCG83FrjFkV6wYRH2+2flSmzbbcueS3YU0YXE3rwrTfMvLeQOtIcc2YR1blm7F/Wzp1dYiOb0iK3wkhZIwUS5W2dvSodKYT338Zsz+9a1Lbv+DOF/3F9hOJ4ShbJXw0I5NXWmIMOkhv/SLu+IxTGogS7fifrb0amuRhlYUWeEjEXgKqKLqsFHh2EhVGwGbTmYvEflGsM5turE7HgbJUnjNvxzfvl6bRqmULbx5abHrDuaOW6o4NFPT3kmcf/3NzjkOmxrIUlTqZ0uvtqru7kydXpbSTEC8C89pIw48A/R6u9vLlw3wTz/4bTNMx0NV1O784g8tK+H1i0sdbdkqYc9Hburs0/1lHH37au3FrNFcxPh3T2sHIdfqDWyZPOb5Bc/SrbifLb3aGtbpZSnN5CRrCp+oEAeeAXpdMDL5sqmiIvszJnhFzEEjUFW6w/3Ff/3iAqwSYeWyQbzaaKIyZOGN5kInP75qyMKDOzYtscev4rS5yNq7DQI6n9E5nV4vlFHiZ0sUtoZxekVa/MwD4sAzQBS35l5fNlVUNP7d0wC1FBxeWAOEqY/f7PnlC6pXVzlQ1Re/ucBYuXwQez5yU1f0fGG+ifHHTwPojuy8ztsCM8pWacm+VOkfldPJ0q24ny1p2ZqlNFM/IA48A8R9a650jppUghuTEWXj29dj/PHTvhcDG9Uipe4CUKs3sOfwGaW9zQW1bV4XFPtOwunYdO9VOZ0s3Yr3YktceeospZn6AVGhZIC4V8l7jX78Pj82UsVKxQBoHVs3DC957jf2zWscm8pZjG9fD6uk3uLWDcNdhThh+ptkvTTbS20TZ5FOkRUfWUQceAaIuw9Gr9GPyedfNZh5aeOu+Ox17NumB36AkS/9oONMAWDqzpuxfLD7z/vQTK3LUQV1OnmoUvTKRccph5SeLslCHFWJmgGjo6N86tSpxPZXZILcArtz4AAwQK1GWm7crzsrJL32F6RVLQF4dvK2zvN1E0ci7Ztiywp1fV2qlXKXCsZ5PitDFphbF6Ugx6rablrozql9X6L7nfP/RcgORDTDzKPu1yUCzyFBI0BVVPTWFereIG9dYXVFTwB89+fVt8WNO6K/shxdnxKgFU3uP6lvyqXLbZ+Y2IYHd2zCG81F1BtN7bHmYaHOqxCnSEU6/Y4sYuaQMFIt94LXuokjyve92mhibvetAC5HpWpd9dL9qVQPWzcMdxXXqFITcXSf9bqxdDoq953M629e8j23eVio85MRRi2HzFrxTr8gDjyHRBEBBh2ya7I/lSrCLq7x+mJH0fc8CLajUskrdTiPNUt6cB0mMsKoHG6Q4p00HX0RLzLiwHNIFBGgnxMyaXBlsj+TtgGqqkugVawztGww0p7oK5eVOvbsOXzGuJOi81jj1FhH6WS8ZIZRyiFN7wjTrNLMaoVor4gDzyFRVdkBeifkF80H2Z/TKV1ZtvD6xUsdzbiXc67PN3Hbu67x7HESBKtE+PJfbOzY5CVPdKI61jg02Gk7mbAXD9M7wjSrNHX7vu/AHKaOno0tGo876hcHnkOiigC9nJBJMUyYFqymThNoKSUOzdRwxy1Vz2k7Jrht9pLM2ZG/u+2AX68UE7ycdJoOrpeLh+kdYZqLv177iOtCmcQFWRx4Tom7IlAX5QfV9Jr2GtfRaC7g0ZMvYpEZq9r9UILO9lTJ+/ychtt5u7+I9x2Yw30H5lApW9jzkZuMz4mXk47bwXlFg71cPEzvCNNc/PVr9xDHhTKJC7LICAUlURVkROF8FpjBaPU/Ceq8rRIpUz1eTuPC/FIJoVeuvN5oYvy7p42LeLxaBuiIQmbpJz0N0k7AjenfSppVmn4jDYHo7wSSuOOQCFzQEkWUn+RgZiUuOaFTGuluYqVrauV3B2HSLyaEqZftikBm6Vd9qevnHqT9rN/xp9kMzLlv3d9j1HcCSdxxiAMXYkV1e+0c6zYQYJhEGJqLjD2HzyidNuOy46r2eKFRRVXuxduwjjgKmaVXNKhrZUBA5NFxms3A7H2rJLJx3AkkITcVBy7Eil/UpSsoCoLfNKB6o9lZPHW/z3beJya2aUvkW7n3Rc9I3B1V9bJ467ftsNvQRYM6587It8ROR1J3AknsRxy4EDth1S4m2H1Pjj9zLvR27M/pIqbdt7emAO05fEbpiK2B7jx7r4u3nW2XCK+/eQnrJo705AC8okFdWiHMbNK8kNSdQNz7kUVMIVVMFpfc2JkIe7Fs79hGnJjYhod2bAq8LeDyhKCxkSruuKXaeV4iwh23VDtfwrndt+KhHZuwaujyomKlbCkHXoRdqLIGCKuGLBBakT8YS/qy7Dowh7UhWth6LTRKC9j8IhF4whSxnNcPr2O2f95/8LRnLrxStjrRb2XIwu7bu6V7qlvW+YuXfPXj9n6nZ2s4NFPrPF9gxqGZGkbfvnqJvSb/XyZ3FvZ4N/tnpZ0nr883O31Z3IMs7GdhNMU623u51e/Hv+csIe1kE0S3eFLkfsmmxzw9W9NOolfloE3Pm0lPF5McuLuwJ4r9OrEGyGjEnc72NOjHv+e0kHayGSDORvpZxfSYx0aq2Ll5TVcL2rJVAjNCnzdn6gDobnHrTBXo0h4X5puBhze4UxaVstVJjaiGOjcXObDz9rI5Cfrx7zlrSAolQfLQRzpqghzz3rGNyu6Fu9qT6E237caZOvC65TddUDWtptOlLKJQ3tik2cK2H/+es4Y48ATJQx/pXlA5x6DHrHJ6OpVEmPPmlcNWKTV01OoNjHzpB518dZDcbxDljbMjo1sumfZCY9H/nvOApFASpMir/bpS7a0bhns+5qTOm0qpUfEoY3eX3JuqQkyVN7aE8cTENjw3eRse3LEpU7Mmi/z3nBdkETNhirpq7zUn0tYa93LMX5x+Go+efLGj2rj7vddj79jGqMzXEmQxslK2sHK52WLn9GzNU3lTIsLX7uqWJ4Yh7N+cyeeK+vecNXSLmOLAhUjwGqLrHpQb9EufttpheraG+zR5eC/8bPTablQDhsOeuzjOuTj78IRWoRDRt4noFSL6ueO11UT0QyL65/bPVVEbLOQL00G5QQcyA+mrHcZGqqGqEv1sHBupLikKchJVHjnsuYv6nIf5fxf8McmBfwfAh1yvTQD4ETPfCOBH7edCH2OaDw3jGLKgdghTMQr427j79pt6ziNPz9awZfIY1ikqNMOeu6jPedoX4aLi68CZ+ccAzrte/iiAfe3H+wCMRWuWkDdMe0KHcQx+0b2XA4sKla7bBL9I2r3dVUMWlg8OYNeBOaNj8YtsTe+MTH8f9s4gCxfhIhJWRng1M7/UfvxbAFfr3khE9wK4FwDWrFkTcndCHjApMw8jPfNqxJTkHEn38ekWbt02mm43zLH4TX0J29I06laoIjmMh55lhNxaBdWuhDLzw8w8ysyjw8PDve5OyDlhpGde0X2at+aqY3E32up1/Fyv6aWwk5WimshkI5LDeAgbgb9MRNcw80tEdA2AV6I0SiguYRsn6aL7OG/N/VQTUfd7Dpte8otsw7Y0jbIV6thIFaeeP79ECmp3ehTCE9aBHwZwD4DJ9s8nI7NIKDxROoa4bs1N0xlpH4tfqiMr0j2TTo9CcHwdOBE9CuCDAK4iol8D2I2W4z5IRJ8G8DyAu+I0UhB09JqrnZ6t4YHvn+m0nLWnzEc1UTyIA9WV8r/+5iVMz9YCt4L1uwgl6dyTmNDuJisXrzjxdeDMfLfmV38csS2CEJhee1mPP356SRdAe8q8uw+3TZDUTNBFSfs15wXFtsnvc6rX/XLqUS/+ejnMpFUoSS5up4n0QhFyz9hIFScmtuHZydtwYmKb8Rd06uhZZQvX5iIrW74CwVIzYRYlx0aqGFrWHVeFWZj1G2ScZKFO1LJEP/pFdy4OXOhbvKK/BeaeVRNpF9F4Oc2kC3WSVqH0i+5cHLjQt3hFf7ZsrhcZXZJFNKpiJi+nmXShTlBZYq/FWUlH/GkhDlzoW8a3r4dVUqdKau00w/j29YFTM87th4k6g35Ol74AEMsgY5VzNXGY9n7tO4Cpo2eVjjmKvin9ojuXboRCX+NWobhJsgOf872VIQvMwKsN/4ERXq18veZlhlFp6LoU3nFLFYdmap7dC007HIY9niiOLyhJKV2knawg+BCV4whDL+1bg7Ty7ZVe+r6bnt8kj6cXkmxzrHPgMlJNENqkufDVi046yT4jXufIr6jJ9PzmpW9KGtp2N5IDF4Q2aS589XLxSDLfa3KOdAuQpuc3L/nrLChdxIELQps0HUcvF4+oG0954XeOvBYgTc9vksfTC1lQukgKRRDaRN2cKgi9tgSIsieL334A/TnySivYeW6T85vU8fRC1C13wyCLmIKQEeJUNCSllsjLAmRUpK1CkQhcEDJCXFFnkn1B8rIAGRVp3ylIDlwQCk6SfUHysgBZFCQCF4SESKu9aZJqCV2OHGjpwIvc2jUNxIELQgKk2d406bSGO63QL61d00BSKIKQAFmb3ZlkWqNfWrumgUTggpAAaRZ9pCmPBLJR8FJUxIELQgKkrc5IUy2R9rEXGUmhCEICpJ3GSJN+Pva4kQhcEBIg7TRGmvTzsceNVGIKgiBkHF0lpqRQBEEQcoo4cEEQhJwiDlwQBCGniAMXBEHIKeLABUEQckqiKhQiOgfgdQC/S2yn4bkK2bczDzYCYmfUiJ3Rkgc7387Mw+4XE3XgAEBEp1RymKyRBzvzYCMgdkaN2BktebFThaRQBEEQcoo4cEEQhJyShgN/OIV9hiEPdubBRkDsjBqxM1ryYmcXiefABUEQhGiQFIogCEJOEQcuCIKQUxJz4ET0ISI6S0S/JKKJpPYbFCJ6joieJqI5IspM60Qi+jYRvUJEP3e8tpqIfkhE/9z+uSpNG9s2qezcQ0S19jmdI6I/T9PGtk3XE9FxIvonIjpDRJ9rv56pc+phZ6bOKRGtIKKfENHptp0PtF9fR0Qn29/7A0S0LKN2foeInnWcz01p2mkMM8f+D0AJwK8AvAPAMgCnAbwziX2HsPU5AFelbYfCrg8AeDeAnzte+xsAE+3HEwC+mlE79wD4z2nb5rLzGgDvbj9+C4D/C+CdWTunHnZm6pwCIABXtB9bAE4C2AzgIIBPtF//JoD/mFE7vwPgzrTPY9B/SUXg7wHwS2b+F2a+COAxAB9NaN+FgJl/DOC86+WPAtjXfrwPwFiSNqnQ2Jk5mPklZv5p+/EfAPwCQBUZO6cedmYKbvFa+6nV/scAtgF4vP16Fs6nzs5ckpQDrwJ40fH818jgH2EbBvADIpohonvTNsaHq5n5pfbj3wK4Ok1jfPhPRPSzdool9VSPEyJaC2AErWgss+fUZSeQsXNKRCUimgPwCoAfonXXXWfmS+23ZOJ777aTme3z+eX2+XyQiJanZ6E5sojZzfuZ+d0A/gzAZ4noA2kbZAK37gmzGkl8A8ANADYBeAnA11K1xgERXQHgEID7mPn3zt9l6Zwq7MzcOWXmBWbeBOA6tO66N6RrkRq3nUT0bwB8AS17/y2A1QA+n56F5iTlwGsArnc8v679WuZg5lr75ysAvofWH2JWeZmIrgGA9s9XUrZHCTO/3P7SLAL4O2TknBKRhZZT3M/MT7Rfztw5VdmZ1XMKAMxcB3AcwPsAVIjInr2bqe+9w84PtVNVzMxvAvhvyND59CIpB/5/ANzYXpFeBuATAA4ntG9jiGglEb3FfgzgVgA/9/5UqhwGcE/78T0AnkzRFi22Q2zzF8jAOSUiAvAtAL9g5q87fpWpc6qzM2vnlIiGiajSflwG8Kdo5euPA7iz/bYsnE+Vnc84LtqEVp4+9b9RExKrxGzLnB5CS5HybWb+ciI7DgARvQOtqBsABgH8fVbsJKJHAXwQrdaXLwPYDWAarVX+NQCeB3AXM6e6gKix84No3eozWiqff+/IM6cCEb0fwP8E8DSAxfbLf4VWfjkz59TDzruRoXNKRO9Ca5GyhFZgeJCZv9T+Tj2GVlpiFsAn21Fu1uw8BmAYLZXKHID/4FjszCxSSi8IgpBTZBFTEAQhp4gDFwRByCniwAVBEHKKOHBBEIScIg5cEAQhp4gDFwRByCniwAVBEHLK/wevSR9MMJ2gqgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "boston = load_boston()\n",
    "plt.scatter(boston.data[:, -1], boston.target);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В **PyTorch** есть возможность при создании тензора указывать нужно ли считать по нему градиент или нет, с помощью параметра `requires_grad`. Когда `requires_grad=True` мы сообщаем фреймворку, о том, что мы хотим следить за всеми тензорами, которые получаются из созданного. Иными словами, у любого тензора, у которого указан данный параметр, будет доступ к цепочке операций и преобразований совершенными с ними. Если эти функции дифференцируемые, то у тензора появляется параметр `.grad`, в котором хранится значение градиента."
   ]
  },
  {
   "attachments": {
    "torch_grad.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![torch_grad.png](attachment:torch_grad.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если к результирующему тензору применить метод `.backward()`, то фреймворк посчитает по цепочке градиенты для всех тензоров, у которых `requires_grad=True`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "w = torch.rand(1, requires_grad=True)\n",
    "b = torch.rand(1, requires_grad=True)\n",
    "\n",
    "x = torch.tensor(boston.data[:, -1] / boston.data[:, -1].max(), dtype=torch.float32)\n",
    "y = torch.tensor(boston.target, dtype=torch.float32)\n",
    "\n",
    "# только создали тензоры и в них нет градиентов\n",
    "assert w.grad is None\n",
    "assert b.grad is None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(torch.Size([506]), torch.Size([506]))"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.size(), y.size()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred = w * x + b\n",
    "loss = torch.mean((y_pred - y) ** 2)\n",
    "loss.backward()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dL/dw = tensor([-12.2880])\n",
      "dL/db = tensor([-44.5911])\n"
     ]
    }
   ],
   "source": [
    "# сделали операции и посчитали градиенты, появилось значение соответствующих полей\n",
    "assert w.grad is not None\n",
    "assert b.grad is not None\n",
    "\n",
    "print(f\"dL/dw = {w.grad}\")\n",
    "print(f\"dL/db = {b.grad}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для доступа к значениям в тензоре используйте атрибут `.data`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([0.3491]), tensor([-12.2880]))"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "w.data, w.grad"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([0.3491], requires_grad=True)"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "w"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss =  48.32032\n"
     ]
    }
   ],
   "source": [
    "from IPython.display import clear_output\n",
    "\n",
    "for i in range(300):\n",
    "    y_pred = w * x + b\n",
    "    # попробуйте сделать полиномиальную регрессию в данном предсказании и посчитать градиенты после\n",
    "    loss = torch.mean((y_pred - y) ** 2)\n",
    "    loss.backward()\n",
    "\n",
    "    # делаем шаг градиентного спуска с lr = .05\n",
    "    w.data -= 0.05 * w.grad\n",
    "    b.data -= 0.05 * b.grad\n",
    "\n",
    "    # обнуляем градиенты, чтобы на следующем шаге опять посчитать и не аккумулировать их\n",
    "    w.grad.data.zero_()\n",
    "    b.grad.data.zero_()\n",
    "\n",
    "    # рисуем картинки\n",
    "    if (i + 1) % 5 == 0:\n",
    "        clear_output(True)\n",
    "        plt.figure(figsize=(10,8))\n",
    "        plt.scatter(x.data.numpy(), y.data.numpy(), label=\"data\")\n",
    "        plt.scatter(x.data.numpy(), y_pred.data.numpy(),\n",
    "                    color=\"orange\", linewidth=5, label=\"predictions\")\n",
    "        plt.xlabel(\"LSTAT\", fontsize=14)\n",
    "        plt.ylabel(\"MEDV (target)\", fontsize=14)\n",
    "        plt.title(\"Boston modelling\", fontsize=18)\n",
    "        plt.legend(fontsize=14)\n",
    "        plt.show()\n",
    "\n",
    "        print(\"loss = \", loss.data.numpy())\n",
    "        if loss.data.numpy() < 0.1:\n",
    "            print(\"Done!\")\n",
    "            break\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. Моя первая нейросеть\n",
    "\n",
    "Для того, чтобы разобраться как обучать нейросети в **PyTorch**, нужно освоить три вещи:\n",
    "\n",
    "1. Как формировать батчи и подавать их на вход сети\n",
    "2. Как задать архитектуру сети\n",
    "3. Как написать цикл обучения и отслеживать метрики\n",
    "\n",
    "#### Как формировать батчи и подавать их на вход нейросети\n",
    "\n",
    "Чтобы иметь возможность итерироваться по данным и применять к ним преобразования (например, аугментации, о которых вы узнаете позже), нужно создать свой класс унаследованный от `torch.utils.data.Dataset`.\n",
    "\n",
    "У такого класса **должно быть** три метода:\n",
    "\n",
    "* `__init__` — создаёт поля класса (например, путь к папке с файлами с тренировочными объектами)\n",
    "* `__len__` — возвращает информацию о том, сколько объектов у нас в датасете\n",
    "* `__getitem__` — по индексу возвращает семпл и таргет к нему\n",
    "\n",
    "\n",
    "Давайте напишем такой сами, в качестве данных используя рандомные значения."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "class RandomDataset(torch.utils.data.Dataset):\n",
    "    \"\"\"\n",
    "    Our random dataset\n",
    "    \"\"\"\n",
    "    def __init__(self, x, y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "        \n",
    "    def __len__(self):\n",
    "        return len(self.x)\n",
    "    \n",
    "    def __getitem__(self, idx):\n",
    "        return {\"sample\": torch.tensor(self.x[idx, :], dtype=torch.float), \"target\": self.y[idx]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.random.rand(1000, 5)\n",
    "y = np.random.rand(1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "our_dataset = RandomDataset(x, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'sample': tensor([0.6788, 0.3202, 0.6422, 0.3080, 0.7729]),\n",
       " 'target': 0.4025345222297003}"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "our_dataset.__getitem__(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для того, чтобы из данных получать батчи в pytorch используется такая сущность как даталоадер, который принимает на вход класс унаследованный от `torch.utils.data.Dataset`. Сейчас посмотрим на пример:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataloader = torch.utils.data.DataLoader(our_dataset, batch_size=4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Работают с ним следующим образом:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sample:\n",
      "tensor([[0.0593, 0.7277, 0.2200, 0.9378, 0.3835],\n",
      "        [0.6788, 0.3202, 0.6422, 0.3080, 0.7729],\n",
      "        [0.6843, 0.6699, 0.5373, 0.3875, 0.3223],\n",
      "        [0.0510, 0.1467, 0.0690, 0.4167, 0.4942]])\n",
      "Target:\n",
      "tensor([0.5249, 0.4025, 0.5927, 0.8436], dtype=torch.float64)\n"
     ]
    }
   ],
   "source": [
    "batch = next(iter(dataloader))\n",
    "\n",
    "print(f\"Sample:\\n{batch['sample']}\")\n",
    "print(f\"Target:\\n{batch['target']}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Как сделать нейросеть"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для того, чтобы в high-level **PyTorch** создавать нейросети, используется модуль `torch.nn`. Нейросеть должна быть унаследована от класса `nn.Module`. Пример как это может выглядеть:\n",
    "\n",
    "```\n",
    "class Model(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Model, self).__init__()\n",
    "        self.conv1 = nn.Conv2d(1, 20, 5)\n",
    "        self.conv2 = nn.Conv2d(20, 20, 5)\n",
    "\n",
    "    def forward(self, x):\n",
    "       x = F.relu(self.conv1(x))\n",
    "       return F.relu(self.conv2(x))\n",
    "```\n",
    "\n",
    "Как мы видим на данном примере, у данного класса **должен быть** метод `forward`, который определяет прямой проход нейросети. Также из класса выше видно, что модуль `nn` содержит в себе реализацию большинства слоев, а модуль `nn.functional` -- функций активаций.\n",
    "\n",
    "Есть еще один способ создать нейросеть и давайте его разберем на практике:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = nn.Sequential()                   # создаем пустую модель, в которую будем добавлять слои\n",
    "model.add_module(\"l1\", nn.Linear(5, 30))  # добавили слой с 5-ю нейронами на вход и 3-мя на выход\n",
    "model.add_module(\"l2\", nn.ReLU())         # добавили функцию активации\n",
    "model.add_module(\"l3\", nn.Linear(30, 1))  # добавили слой с 3-мя нейронами на вход и 5-ю на выход\n",
    "\n",
    "# альтернативный способ\n",
    "another_model = nn.Sequential(\n",
    "    nn.Linear(5, 30),\n",
    "    nn.ReLU(),\n",
    "    nn.Linear(30, 1)\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred = model(batch['sample'])  # получили предсказания модели"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Как написать цикл обучения и отслеживать метрики\n",
    " \n",
    "Давайте теперь соберем теперь загрузку данных, создание модели и обучим на уже созданном для нас датасете MNIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "# используем готовый класс от торча для загрузки данных для тренировки\n",
    "mnist_train = torchvision.datasets.MNIST(\n",
    "    \"./mnist/\", \n",
    "    train=True, \n",
    "    download=True, \n",
    "    transform=torchvision.transforms.ToTensor()\n",
    ") \n",
    "mnist_val = torchvision.datasets.MNIST(\n",
    "    \"./mnist/\",\n",
    "    train=False, \n",
    "    download=True,\n",
    "    transform=torchvision.transforms.ToTensor()\n",
    ")\n",
    "\n",
    "# так как это уже унаследованный от Dataset класс, его можно сразу обернуть в даталоадер\n",
    "train_dataloader = torch.utils.data.DataLoader(\n",
    "    mnist_train, \n",
    "    batch_size=4, \n",
    "    shuffle=True, \n",
    "    num_workers=1\n",
    ") \n",
    "\n",
    "val_dataloader = torch.utils.data.DataLoader(\n",
    "    mnist_val, \n",
    "    batch_size=4, \n",
    "    shuffle=False, \n",
    "    num_workers=1\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# посмотрим на то, с чем мы работаем\n",
    "for i in [0, 1]:\n",
    "    plt.subplot(1, 2, i + 1)\n",
    "    plt.imshow(mnist_train[i][0].squeeze(0).numpy().reshape([28, 28]))\n",
    "    plt.title(str(mnist_train[i][1]))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = nn.Sequential(\n",
    "    nn.Flatten(),             # превращаем картинку 28х28 в вектор размером 784\n",
    "    nn.Linear(28 * 28, 128),  # линейный слой, преобразующий вектор размера 784 в вектор размера 128\n",
    "    nn.ReLU(),                # нелинейность\n",
    "    nn.Linear(128, 10),       # линейный слой, преобразующий вектор размера 128 в вектор размера 10\n",
    ")\n",
    "\n",
    "# создаем оптимизатор, который будет обновлять веса модели\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=0.05)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Веса моделей хранятся в виде матриц и выглядят так:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('1.weight',\n",
       "  Parameter containing:\n",
       "  tensor([[ 0.0098, -0.0059,  0.0073,  ...,  0.0356, -0.0096,  0.0089],\n",
       "          [-0.0260, -0.0141, -0.0281,  ..., -0.0111, -0.0181,  0.0221],\n",
       "          [-0.0090, -0.0032, -0.0167,  ..., -0.0155,  0.0014,  0.0137],\n",
       "          ...,\n",
       "          [ 0.0338,  0.0097,  0.0166,  ..., -0.0173,  0.0055, -0.0181],\n",
       "          [-0.0143,  0.0210,  0.0042,  ...,  0.0206,  0.0198,  0.0019],\n",
       "          [ 0.0291,  0.0225, -0.0251,  ...,  0.0115,  0.0263,  0.0131]],\n",
       "         requires_grad=True)),\n",
       " ('1.bias',\n",
       "  Parameter containing:\n",
       "  tensor([-0.0308, -0.0211,  0.0159,  0.0013, -0.0124, -0.0117, -0.0165,  0.0140,\n",
       "          -0.0010, -0.0030, -0.0051, -0.0012,  0.0166, -0.0184, -0.0004,  0.0259,\n",
       "          -0.0043, -0.0088, -0.0114, -0.0216,  0.0213,  0.0100,  0.0208, -0.0320,\n",
       "           0.0276, -0.0063, -0.0347, -0.0124,  0.0073,  0.0230,  0.0128,  0.0147,\n",
       "           0.0095, -0.0347, -0.0061, -0.0192,  0.0039, -0.0326, -0.0255, -0.0038,\n",
       "           0.0342, -0.0145, -0.0288, -0.0071, -0.0072,  0.0148, -0.0230, -0.0346,\n",
       "           0.0002,  0.0143, -0.0141, -0.0196,  0.0322, -0.0321,  0.0089,  0.0203,\n",
       "          -0.0022,  0.0231, -0.0233, -0.0195,  0.0075,  0.0106, -0.0185, -0.0337,\n",
       "          -0.0248, -0.0150,  0.0023, -0.0106,  0.0030,  0.0064,  0.0287,  0.0350,\n",
       "           0.0316,  0.0296, -0.0123, -0.0046,  0.0286,  0.0127, -0.0157,  0.0263,\n",
       "           0.0028, -0.0129, -0.0066, -0.0068, -0.0289, -0.0156,  0.0154, -0.0357,\n",
       "           0.0045, -0.0051,  0.0146,  0.0301,  0.0153, -0.0013, -0.0146, -0.0055,\n",
       "          -0.0294,  0.0201,  0.0253, -0.0024, -0.0298,  0.0218, -0.0345,  0.0021,\n",
       "           0.0180,  0.0262,  0.0146,  0.0257, -0.0050, -0.0026, -0.0082,  0.0332,\n",
       "           0.0281,  0.0274, -0.0086, -0.0211,  0.0026,  0.0080, -0.0022,  0.0140,\n",
       "           0.0052,  0.0289, -0.0346, -0.0278, -0.0004, -0.0159, -0.0050, -0.0262],\n",
       "         requires_grad=True)),\n",
       " ('3.weight',\n",
       "  Parameter containing:\n",
       "  tensor([[-0.0578,  0.0688, -0.0048,  ..., -0.0752, -0.0478, -0.0227],\n",
       "          [-0.0675, -0.0088, -0.0036,  ..., -0.0878,  0.0521,  0.0297],\n",
       "          [-0.0614, -0.0482,  0.0061,  ...,  0.0527, -0.0749,  0.0239],\n",
       "          ...,\n",
       "          [-0.0798,  0.0796,  0.0553,  ..., -0.0265,  0.0268, -0.0186],\n",
       "          [ 0.0107,  0.0631,  0.0873,  ...,  0.0494,  0.0666,  0.0165],\n",
       "          [-0.0862,  0.0304,  0.0757,  ...,  0.0053, -0.0491, -0.0499]],\n",
       "         requires_grad=True)),\n",
       " ('3.bias',\n",
       "  Parameter containing:\n",
       "  tensor([ 0.0248, -0.0319, -0.0393,  0.0205,  0.0689,  0.0479,  0.0300,  0.0503,\n",
       "           0.0591, -0.0114], requires_grad=True))]"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[x for x in model.named_parameters()] "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Вместо того, чтобы каждый раз самим рисовать графики в `matplotlib`, мы будем _красиво_ трекать метрики в полуавтоматическом режиме в [wandb](https://wandb.ai). Для этого регистрируемся на сайте, устанавливаем и логинимся (это того стоит).\n",
    "\n",
    "Note. Помимо этого инструмента есть другие альтернативы: Tensorboard (очень минималистичный, работает локально), MLFlow (менее красивый, но опенсорсный), Neptune (примерно как W&B)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": true
    }
   },
   "outputs": [],
   "source": [
    "# !pip install wandb --upgrade --quiet\n",
    "import wandb\n",
    "\n",
    "# логинимся в своего пользователя (предварительно нужно ввести ключ из настроек с wandb.ai через консоль)\n",
    "wandb.login()\n",
    "# инициализируем проект\n",
    "wandb.init(project=\"pytorch-demo\")\n",
    "# сохраняем параметры сетки в wandb + просим следить за градиентами сетки\n",
    "wandb.watch(model);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Можно перейти по ссылке и следить за нашей моделью прямо во время обучения!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8901e19b940f47bcb2a52cb0c0e83fcf",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/15000 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2c41e25ab8c742da98a92cb59e14ce37",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/2500 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0, loss: 0.10789481550455093, accuracy: 0.9673\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "59960b06c342435d8cb267383a11f24d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/15000 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "115f0f6563d4432d8c817cacf936386c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/15000 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ba6c4461368c4b059c84bfaf76b0f86f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/2500 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 2, loss: 0.08681301027536392, accuracy: 0.9744\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c42dbf55de2449f2baba910ecde991f9",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/15000 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a167c306bbbc426b8af8a6d7232d1f69",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/15000 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "36d005fc7d214cb98513fce56786a2ac",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/2500 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 4, loss: 0.08897168189287186, accuracy: 0.9734\n"
     ]
    }
   ],
   "source": [
    "# всего у нас будет 5 эпох (5 раз подряд пройдемся по всем батчам из трейна)\n",
    "for epoch in range(5):\n",
    "    for x_train, y_train in tqdm(train_dataloader):    # берем батч из трейн лоадера\n",
    "        y_pred = model(x_train)                        # делаем предсказания\n",
    "        loss = F.cross_entropy(y_pred, y_train)        # считаем лосс\n",
    "        loss.backward()                                # считаем градиенты обратным проходом\n",
    "        optimizer.step()                               # обновляем параметры сети\n",
    "        optimizer.zero_grad()                          # обнуляем посчитанные градиенты параметров\n",
    "    \n",
    "    if epoch % 2 == 0:\n",
    "        val_loss = []                                  # сюда будем складывать **средний по бачу** лосс\n",
    "        val_accuracy = []\n",
    "        with torch.no_grad():                          # на валидации запрещаем фреймворку считать градиенты по параметрам\n",
    "            for x_val, y_val in tqdm(val_dataloader):  # берем батч из валидационного лоадера\n",
    "                y_pred = model(x_val)                  # делаем предсказания\n",
    "                loss = F.cross_entropy(y_pred, y_val)  # считаем лосс\n",
    "                val_loss.append(loss.numpy())          # добавляем в массив \n",
    "                val_accuracy.extend((torch.argmax(y_pred, dim=-1) == y_val).numpy().tolist())\n",
    "          \n",
    "        # скидываем метрики на wandb и автоматом смотрим на графики\n",
    "        wandb.log({\"mean val loss\": np.mean(val_loss),\n",
    "                   \"mean val accuracy\": np.mean(val_accuracy)})\n",
    "        \n",
    "        # печатаем метрики\n",
    "        print(f\"Epoch: {epoch}, loss: {np.mean(val_loss)}, accuracy: {np.mean(val_accuracy)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Дополнительные материалы:\n",
    "\n",
    "* [Хорошая книга про pytorch](https://isip.piconepress.com/courses/temple/ece_4822/resources/books/Deep-Learning-with-PyTorch.pdf)\n",
    "* [Использование pytorch на GPU](https://pytorch.org/docs/master/notes/cuda.html)\n",
    "* [Pytorch за 60 минут](http://pytorch.org/tutorials/beginner/deep_learning_60min_blitz.html)\n",
    "* [Как устроено автоматическое дифференцирование в pytorch](http://videolectures.net/site/normal_dl/tag=1129745/deeplearning2017_johnson_automatic_differentiation_01.pdf)"
   ]
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}