PytorchTutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center>\n",
    "    <img src=\"cover.png\" width=\"100%\">\n",
    "  \n",
    "</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "![deep learning history](DeepLearningTimeline.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Redes Neurais: Visão Tradicional\n",
    "![redes tradicionais](TraditionalNeuralNetwork.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Redes Neurais em 2018\n",
    "<center><img src=\"qanet.png\" style=\"height: 700px; align:center\">\n",
    "<div style=\"font-size: 8pt\">QANET: COMBINING LOCAL CONVOLUTION WITH GLOBAL SELF-ATTENTION FOR READING COMPREHENSION (https://arxiv.org/pdf/1804.09541.pdf)</div></center>\n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center><img src=\"lipsync.png\" style=\"height: 700px; align:center\">\n",
    "<div style=\"font-size: 8pt\">Lip Reading Sentences in the Wild* (https://arxiv.org/pdf/1611.05358v1.pdf)</div></center>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center><img src=\"reasoning.png\">\n",
    "<div style=\"font-size: 8pt\">A simple neural network module\n",
    "for relational reasoning (https://arxiv.org/pdf/1706.01427.pdf)</div></center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Receita para criar uma Rede Neural \n",
    "<br>\n",
    "\n",
    "## Ingedientes:\n",
    "\n",
    "<br>\n",
    "<br>\n",
    "- Dados\n",
    "- Estrutura da Rede\n",
    "- Função Objetivo\n",
    "- Otimizador\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Modo de preparo\n",
    "\n",
    "    \n",
    "    inicialize learning_rate com constante de velocidade de aprendizado\n",
    "\n",
    "    instancie a estrutura da Rede Neural\n",
    "\n",
    "    inicialize os parâmetros com valores aleatórios (pequenos)\n",
    "\n",
    "    repita:\n",
    "\n",
    "        \"forward pass\":\n",
    "            selecione um subconjunto dos dados de treino (minibatch)\n",
    "            obtenha saídas da rede para os exemplos do minibatch\n",
    "            compare as saídas obtidas com o esperado (função de perda)\n",
    "        \n",
    "        \"backward pass\":\n",
    "            calcule o gradiente entre a função de perda e a última camada\n",
    "            para cada camada da penúltima até a primeira:\n",
    "                calcule o gradiente entre a camada N-1 e a camada N\n",
    "            \n",
    "         \"optimize\":\n",
    "            atualize todos os pesos da rede usando a equação (otimizador):\n",
    "               w = w - learning_rate * gradient\n",
    "       \n",
    "\n",
    "    até a convergência do treinamento.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: white\">\n",
    "<img src=\"NeuralNetworking_transp.gif\" width=\"70%\">\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Frameworks de Deep Learning\n",
    "\n",
    "![](FrameworksDeepLearning.png)\n",
    "<br/>\n",
    "\n",
    "Objetivos: \n",
    "- Encapsular os passos \"forward\", \"backward\" e \"optimize\"\n",
    "- Fornecer blocos de código reusável para a definição da estrutura dos modelos\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Frameworks estáticos: Grafo Computacional\n",
    "<center>\n",
    "![tensors flowing](tensors_flowing.gif)\n",
    "</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  Exemplo: Tensorflow vs PyTorch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "\n",
    "# Initialize two constants\n",
    "x1 = tf.constant([1,2,3,4])\n",
    "x2 = tf.constant([5,6,7,8])\n",
    "\n",
    "# Multiply\n",
    "graph = tf.multiply(x1, x2)\n",
    "\n",
    "# Intialize the Session\n",
    "sess = tf.Session()\n",
    "\n",
    "# Print the result\n",
    "result=sess.run(graph)\n",
    "print(result)\n",
    "\n",
    "# Close the session\n",
    "sess.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([  5.,  12.,  21.,  32.])\n"
     ]
    }
   ],
   "source": [
    "# Import PyTorch\n",
    "import torch\n",
    "\n",
    "x1=torch.Tensor([1,2,3,4])\n",
    "x2=torch.Tensor([5,6,7,8])\n",
    "\n",
    "result=x1*x2\n",
    "\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Frameworks dinâmicos\n",
    "\n",
    "- Menos código\n",
    "- Execução mais intuitiva\n",
    "- Depuração mais simples\n",
    "- Arquiteturas adaptáveis e modulares\n",
    "\n",
    "# Frameworks estáticos\n",
    "\n",
    "- Melhor otimização de recursos\n",
    "- Maior desempenho\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PyTorch\n",
    "<center>\n",
    "<img src=\"PyTorchSite.png\" width=60%>\n",
    "    </center>\n",
    "- Versão Inicial: Outubro / 2016\n",
    "- Versão atual: 0.4 (24/04/2018) --> Mudanças significativas na API!!\n",
    "- Próxima versão: 1.0 (\"summer 2018\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"karpathy.png\" width=\"70%\">\n",
    " </center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tensors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([ 1.,  2.,  3.,  4.])\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "\n",
    "x=torch.Tensor([1,2,3,4])\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([4])\n"
     ]
    }
   ],
   "source": [
    "print(x.size())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ 0.,  0.,  0.,  0.,  0.],\n",
      "        [ 0.,  0.,  0.,  0.,  0.],\n",
      "        [ 0.,  0.,  0.,  0.,  0.],\n",
      "        [ 0.,  0.,  0.,  0.,  0.],\n",
      "        [ 0.,  0.,  0.,  0.,  0.],\n",
      "        [ 0.,  0.,  0.,  0.,  0.],\n",
      "        [ 0.,  0.,  0.,  0.,  0.],\n",
      "        [ 0.,  0.,  0.,  0.,  0.],\n",
      "        [ 0.,  0.,  0.,  0.,  0.],\n",
      "        [ 0.,  0.,  0.,  0.,  0.]])\n"
     ]
    }
   ],
   "source": [
    "x=torch.zeros(10,5)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([10, 5])\n"
     ]
    }
   ],
   "source": [
    "print(x.size())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[  15.,    0.,    0.,    0., -100.],\n",
      "        [  -1.,   -1.,   -1.,   -1.,   -1.],\n",
      "        [   0.,    0.,    0.,    0.,    0.],\n",
      "        [   0.,    0.,    0.,    0.,    0.],\n",
      "        [   0.,    0.,    0.,    0.,    0.],\n",
      "        [   0.,    0.,    0.,    0.,    0.],\n",
      "        [   0.,    0.,    0.,    0.,    0.],\n",
      "        [   0.,    0.,    0.,    0.,    0.],\n",
      "        [   0.,    0.,    0.,    0.,    0.],\n",
      "        [   0.,    0.,    0.,    0.,    0.]])\n"
     ]
    }
   ],
   "source": [
    "x[0][0]=15\n",
    "x[1][:]=-1\n",
    "x[0][-1]=-100\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exemplo: Regressão Linear em PyTorch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Definindo o conjunto de dados \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import matplotlib.pyplot as plt\n",
    "plt.rcParams['figure.figsize'] = [10, 5]\n",
    "plt.rcParams['xtick.color'] = 'white'\n",
    "plt.rcParams['ytick.color'] = 'white'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<torch._C.Generator at 0x7f06342351d0>"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.manual_seed(42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "data_X = torch.linspace(-1, 1, 101)\n",
    "data_Y = 2 * data_X + torch.randn(data_X.size()) * 0.33\n",
    "\n",
    "plt.scatter(data_X,data_Y)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Definindo o modelo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "A=torch.randn(1,requires_grad=True)\n",
    "B=torch.randn(1,requires_grad=True)\n",
    "\n",
    "def model(x):\n",
    "    return A*x+B"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Treinamento"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 0 , error 1.721\n",
      "Epoch 1 , error 1.467\n",
      "Epoch 2 , error 1.214\n",
      "Epoch 3 , error 0.963\n",
      "Epoch 4 , error 0.724\n",
      "Epoch 5 , error 0.501\n",
      "Epoch 6 , error 0.343\n",
      "Epoch 7 , error 0.287\n",
      "Epoch 8 , error 0.282\n",
      "Epoch 9 , error 0.282\n"
     ]
    }
   ],
   "source": [
    "# Como chegar aos coeficientes A e B a partir dos dados?\n",
    "# Vamos implementar uma solução usando Stochastic Gradient Descent\n",
    "\n",
    "learning_rate=0.01\n",
    "num_training_instances=data_X.size(0)\n",
    "a_history={}\n",
    "for i in range(0,10):\n",
    "    \n",
    "    epoch_error=0\n",
    "    \n",
    "    # Forward\n",
    "    y=model(data_X)\n",
    "    # Loss function\n",
    "    error= torch.abs(y-data_Y).sum()  # Erro total \n",
    "    \n",
    "    # Backward  \n",
    "    error.backward()\n",
    "    \n",
    "    #Optimizer \n",
    "    with torch.no_grad():\n",
    "        a_history[i]=A.item()\n",
    "        A-=learning_rate*A.grad\n",
    "        B-=learning_rate*B.grad\n",
    "    \n",
    "    A.grad.zero_()\n",
    "    B.grad.zero_()\n",
    "        \n",
    "    print(\"Epoch %d , error %.3f\"%(i,error/num_training_instances))    \n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Avaliação"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "slideshow": {
     "slide_type": ""
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x7f06112d0d30>"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pred_Y=model(data_X)\n",
    "plt.scatter(data_X,data_Y,color=\"blue\")\n",
    "plt.scatter(data_X,pred_Y.detach().numpy(),color=\"red\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x7f06112af4a8>"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(a_history.keys(),a_history.values())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exemplo 2: Predição de Diabetes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Leitura do dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Pregnancies</th>\n",
       "      <th>Glucose</th>\n",
       "      <th>BloodPressure</th>\n",
       "      <th>SkinThickness</th>\n",
       "      <th>Insulin</th>\n",
       "      <th>BMI</th>\n",
       "      <th>DiabetesPedigreeFunction</th>\n",
       "      <th>Age</th>\n",
       "      <th>Outcome</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>6</td>\n",
       "      <td>148</td>\n",
       "      <td>72</td>\n",
       "      <td>35</td>\n",
       "      <td>0</td>\n",
       "      <td>33.6</td>\n",
       "      <td>0.627</td>\n",
       "      <td>50</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>85</td>\n",
       "      <td>66</td>\n",
       "      <td>29</td>\n",
       "      <td>0</td>\n",
       "      <td>26.6</td>\n",
       "      <td>0.351</td>\n",
       "      <td>31</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>8</td>\n",
       "      <td>183</td>\n",
       "      <td>64</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>23.3</td>\n",
       "      <td>0.672</td>\n",
       "      <td>32</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1</td>\n",
       "      <td>89</td>\n",
       "      <td>66</td>\n",
       "      <td>23</td>\n",
       "      <td>94</td>\n",
       "      <td>28.1</td>\n",
       "      <td>0.167</td>\n",
       "      <td>21</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0</td>\n",
       "      <td>137</td>\n",
       "      <td>40</td>\n",
       "      <td>35</td>\n",
       "      <td>168</td>\n",
       "      <td>43.1</td>\n",
       "      <td>2.288</td>\n",
       "      <td>33</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Pregnancies  Glucose  BloodPressure  SkinThickness  Insulin   BMI  \\\n",
       "0            6      148             72             35        0  33.6   \n",
       "1            1       85             66             29        0  26.6   \n",
       "2            8      183             64              0        0  23.3   \n",
       "3            1       89             66             23       94  28.1   \n",
       "4            0      137             40             35      168  43.1   \n",
       "\n",
       "   DiabetesPedigreeFunction  Age  Outcome  \n",
       "0                     0.627   50        1  \n",
       "1                     0.351   31        0  \n",
       "2                     0.672   32        1  \n",
       "3                     0.167   21        0  \n",
       "4                     2.288   33        1  "
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "diabetes = pd.read_csv('diabetes.csv')\n",
    "diabetes.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pre-processamento:\n",
    "- Separa features e target\n",
    "- Converte target de [0,1] para [-1,1]\n",
    "- Normaliza features para [0,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn import preprocessing\n",
    "\n",
    "diabetes['Outcome'].replace(to_replace=[0],value=-1,inplace=True)\n",
    "\n",
    "diabetes_features=diabetes.loc[:,diabetes.columns!='Outcome']\n",
    "\n",
    "diabetes_target=diabetes.loc[:,diabetes.columns=='Outcome'].values\n",
    "\n",
    "# Converte valores para a mesma escala (entre 0 e 1)\n",
    "\n",
    "minmax_scale = preprocessing.MinMaxScaler().fit(diabetes_features)\n",
    "diabetes_features=minmax_scale.transform(diabetes_features)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Divisão do Dataset\n",
    "- Cria splits de treino e teste\n",
    "- Converte valores de ndarray para Tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Size of X feature set: \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "torch.Size([576, 8])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "X_train, X_test,Y_train,Y_test = train_test_split(diabetes_features,diabetes_target)\n",
    "\n",
    "X_train_tensor=torch.from_numpy(X_train).float()\n",
    "Y_train_tensor=torch.from_numpy(Y_train).float()\n",
    "\n",
    "print(\"Size of X feature set: \")\n",
    "X_train_tensor.size()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define Rede Neural "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn.functional as F\n",
    "class DiabetesPredictionModel(torch.nn.Module):\n",
    "     def __init__(self):\n",
    "            super(DiabetesPredictionModel, self).__init__()\n",
    "        \n",
    "            self.linear_projection1=torch.nn.Linear(8,2)\n",
    "            self.linear_projection2=torch.nn.Linear(2,1)  \n",
    "            \n",
    "     def forward(self,x):\n",
    "        \n",
    "        output=F.tanh(self.linear_projection1(x))\n",
    "        output=F.tanh(self.linear_projection2(output))\n",
    "\n",
    "        return output\n",
    "    \n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pytorch Building Blocks\n",
    "<img src=\"torch_nn.png\" height=600px >"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"linear.png\" width=\"70%\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Instancia Rede Neural e hiperparâmetros"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "model=DiabetesPredictionModel()\n",
    "minibatch_size=32\n",
    "learning_rate=1e-2\n",
    "\n",
    "with torch.no_grad():\n",
    "    for param in model.parameters():\n",
    "        param.uniform_(0,0.01)\n",
    "\n",
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "import torch.optim as optim\n",
    "\n",
    "optimizer=optim.Adam(model.parameters(),0.01)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loop de Treino"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x7f06113bd160>"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "losses={}\n",
    "total_loss=0\n",
    "for i in range(0,2000):\n",
    "    # Seleciona um minibatch aleatório a partir do treino\n",
    "    minibatch_index=torch.randperm(X_train_tensor.size(0))\n",
    "    minibatch_index=minibatch_index[:minibatch_size]\n",
    "    minibatch_x=X_train_tensor[minibatch_index]\n",
    "    minibatch_y=Y_train_tensor[minibatch_index]\n",
    "\n",
    "    #Forward pass\n",
    "    output=model(minibatch_x)\n",
    "    loss=F.soft_margin_loss(output,minibatch_y)\n",
    "    \n",
    "    # Backward pass\n",
    "    loss.backward()\n",
    "    total_loss+=loss.item()\n",
    "    # Optimizer pass\n",
    "    optimizer.step()\n",
    "    optimizer.zero_grad()\n",
    "    \n",
    "    if i>0 and i%10==0:\n",
    "        losses[i]=total_loss/i\n",
    "    \n",
    "plt.scatter(losses.keys(),losses.values())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"soft_margin_loss.png\" width=\"70%\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Avaliação do modelo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train accuracy: 78.12%\n",
      "Test accuracy: 77.60%\n"
     ]
    }
   ],
   "source": [
    "def evaluate(model):\n",
    "    with torch.no_grad():\n",
    "        # Avalia no conjunto de testes\n",
    "        X_test_tensor=torch.from_numpy(X_test).float()\n",
    "        Y_test_tensor=torch.from_numpy(Y_test).float()\n",
    "\n",
    "        y_train_pred=model(X_train_tensor)\n",
    "        y_test_pred=model(X_test_tensor)\n",
    "\n",
    "        train_accuracy=accuracy_score(Y_train_tensor.gt(0),y_train_pred.gt(0))\n",
    "        test_accuracy=accuracy_score(Y_test_tensor.gt(0),y_test_pred.gt(0))\n",
    "        print(\"Train accuracy: %.2f%%\"%(100*train_accuracy))\n",
    "        print(\"Test accuracy: %.2f%%\"%(100*test_accuracy)) \n",
    "evaluate(model)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Salvando o modelo "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "slideshow": {
     "slide_type": ""
    }
   },
   "outputs": [],
   "source": [
    "torch.save(model.state_dict(),'./models/diabetes_model.dat')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Carregando o modelo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "slideshow": {
     "slide_type": ""
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before load:\n",
      "Train accuracy: 45.66%\n",
      "Test accuracy: 47.92%\n",
      "After load:\n",
      "Train accuracy: 78.12%\n",
      "Test accuracy: 77.60%\n"
     ]
    }
   ],
   "source": [
    "model2=DiabetesPredictionModel()\n",
    "print(\"Before load:\")\n",
    "evaluate(model2)\n",
    "\n",
    "model2.load_state_dict(torch.load('./models/diabetes_model.dat'))\n",
    "print(\"After load:\")\n",
    "evaluate(model2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualização da representação interna"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x7f06113596a0>"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "X_test_tensor=torch.from_numpy(X_test).float()\n",
    "Y_test_tensor=torch.from_numpy(Y_test).float()\n",
    "network_representation=model.linear_projection1(X_test_tensor).detach()\n",
    "\n",
    "plt.scatter(x=network_representation[:,0].numpy(),\n",
    "            y=network_representation[:,1].numpy(),\n",
    "            c=Y_test_tensor.gt(0).squeeze())"
   ]
  }
 ],
 "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}