Perceptron.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No notebook anterior, nós aprendemos intuitivamente como o perceptron aprende. De maneira geral, nós vamos atualizando os pesos e o bias sempre buscando diminuir uma função de custo. Nesse notebook, nós vamos ver como esse aprendizado realmente acontence, tanto na teoria quanto na prática. Também utilizaremos o Perceptron para resolver problemas de classificação e regressão.\n",
    "\n",
    "__Objetivos__:\n",
    "\n",
    "- Implementar o perceptron e seu modelo de aprendizado em Python puro e Numpy\n",
    "- Utilizar o perceptron para regressão e classificação"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sumário"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Introdução](#Introdução)\n",
    "- [Regra de Aprendizado do Perceptron](#Regra-de-Aprendizado-do-Perceptron)\n",
    "- [Pseudo-algoritmo do Perceptron](#Pseudo-algoritmo-do-Perceptron)\n",
    "\n",
    "[Classificação](#Classificação)\n",
    "- [Porta AND/OR](#Porta-AND/OR)\n",
    "- [Exercício de Classificação](#Exerc%C3%ADcio-de-Classificação)\n",
    "\n",
    "[Regressão](#Regressão)\n",
    "- [Exercício de Regressão](#Exerc%C3%ADcio-de-Regressão)\n",
    "\n",
    "[Referências](#Referências)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Imports e Configurações"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-05-03T21:23:16.761446Z",
     "start_time": "2023-05-03T21:23:15.392673Z"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from random import random\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "from sklearn.datasets import make_blobs\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introdução"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O tipo mais básico de Rede Neural Artificial é formada por apenas um neurônio, o __Perceptron__. Inicialmente, o Perceptron foi projetado para ser um __classificador binário linear__ responsável por mapear uma ou mais entradas em uma saída desejada. Porém, também podemos utilizá-lo para resolver problemas de __regressão linear__. Ele foi projetado em 1957 por Frank Rosenblatt.\n",
    "\n",
    "O perceptron é formado por:\n",
    "\n",
    "<img src='images/perceptron.png' width='350'>\n",
    "\n",
    "- __entradas__ $x_1,...,x_D$: representam os atributos dos seus dados com dimensionalidade $D$. O Perceptron aceita qualquer tamanho de entrada, porém a saída é sempre apenas um valor.\n",
    "- __junção aditiva__ $\\sum$: também chamada de _função agregadora_, nada mais é que a soma ponderada das entradas com os __pesos__ ($w_1,...,w_D)$. Em geral, o resultado é somado com um __bias__ $b$, responsável por deslocar o resultado do somatório. A junção aditiva é descrita pela seguinte fórmula:\n",
    "\n",
    "$$\\sum_i^D{x_iw_i} + b$$\n",
    "\n",
    "- __função de ativação__ $f$: utilizada para mapear o resultado da junção aditiva em uma saída esperada. Mais detalhes abaixo.\n",
    "\n",
    "Logo, o Perceptron é representado pela seguinte fórmula matemática:\n",
    "\n",
    "$$\\widehat{y}_i = f(\\sum_i^D{x_iw_i} + b)$$\n",
    "\n",
    "Onde:\n",
    "\n",
    "- $D$: representa a dimensionalidade das amostras, ou seja, a quantidade de atributos de cada amostra.\n",
    "- $x_i$: representam os atributos de uma amostra que servem de entrada para o Perceptron.\n",
    "- $w_i$: representam os __pesos sinápticos__ que ponderam as entradas.\n",
    "- $b$: representa o __bias__, responsável por deslocar a fronteira de decisão além da origem e não depende de nenhum valor de entrada. Repare que o bias encontra-se fora do somatório.\n",
    "- $f$: __função de ativação__. Quando a função de ativação é linear, ou seja, nenhuma transformação é aplicada no resultado da junção aditiva, o Perceptron atua como um __Regressor Linear__. Se precisamos efetuar uma __Classificação binária__, devemos utilizar a função _step_ (também conhecida como _função degrau_) para mapear a saída em um valor discreto (0 ou 1):\n",
    "\n",
    "$$f = \\begin{cases}1 & se \\ wx+b > 0\\\\0 & caso \\ contr\\acute ario\\end{cases}$$\n",
    "\n",
    "- $\\widehat{y}$: representa a saída do Perceptron (o valor predito).\n",
    "\n",
    "__Observações importantes__:\n",
    "\n",
    "- O Perceptron não faz __Classificação Multiclasse__.\n",
    "- __A atualização dos pesos é *online*, ou seja, efetuada amostra a amostra__ utilizando uma fórmula pré-definida que veremos na seção a seguir."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Regra de Aprendizado do Perceptron"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O Perceptron tem sua própria forma de aprendizado conforme definido no seu artigo original. Na verdade, a fórmula para atualização dos pesos e bias é bem simples:\n",
    "\n",
    "$$w_i = w_i + \\lambda(y_i - \\widehat{y}_i)x_i$$\n",
    "<br>\n",
    "$$b_i = b_i + \\lambda(y_i - \\widehat{y}_i)$$\n",
    "\n",
    "Onde $\\lambda$ é a __taxa de aprendizagem__ (___learning rate___).\n",
    "\n",
    "Repare que $y_i - \\widehat{y}_i$ significa calcular a diferença entre o valor esperado ($y_i$) e o valor predito ($\\widehat{y}_i$). Supondo que estamos fazendo __classificação binária__ de uma amostra $(x_i, y_i)$. Nesse caso, teremos duas possibilidades:\n",
    "- __O valor esperado é $y_i = \\widehat{y}_i$__, ou seja, a saída do Perceptron (após a função de ativação _step_) é __igual__ a saída esperada. Nesse caso, __a diferença $y_i - \\widehat{y}_i = 0$ e não haverá atualização de pesos__.\n",
    "- __O valor esperado é $y_i \\neq \\widehat{y}_i$__, ou seja, a saída do Perceptron (após a função de ativação _step_) é __diferente__ da saída esperada. Nesse caso, __a atualização dos pesos será dada pela diferença $y_i - \\widehat{y}_i$__. Repare que:\n",
    "    - quando essa diferença é __negativa__ (ou seja, $y_i = 0$ e $\\widehat{y}_i = 1$), __os pesos tendem a diminuir__.\n",
    "    - quando essa diferença é __positiva__ (ou seja, $y_i = 1$ e $\\widehat{y}_i = 0$), __os pesos tendem a aumentar__."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pseudo-algoritmo do Perceptron"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Inicialize os pesos $w$ e o bias $b$\n",
    "2. Para cada amostra $(x_n, y_n)$ do nosso banco:\n",
    "    1. Calcule $\\widehat{y} = f(\\sum_i^D{x_iw_i} + b)$, onde $f$ é a __função _step_ para classificação__ e __linear no caso da regressão__\n",
    "    2. Calcule o $erro = y_n - \\widehat{y}$\n",
    "    3. Atualize os pesos $w_i = w_i + \\lambda*erro*x_i$\n",
    "    4. Atualize o bias $b_i = b_i + \\lambda*erro$\n",
    "3. Repita o passo 2 por N vezes ou até que alguma medida de custo para o $erro$ seja menor que um valor pré-determinado.\n",
    "    \n",
    "Repare, como dito lá em cima, que __a atualização dos pesos e bias é feito a cada amostra__, e não somente após ver todas as amostras do banco."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Classificação"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Porta AND/OR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-05-03T21:23:16.764648Z",
     "start_time": "2023-05-03T21:23:16.762361Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(4, 2) (4,)\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])\n",
    "#y = np.array([0, 1, 1, 1]) # porta OR\n",
    "y = np.array([0, 0, 0, 1]).T # porta AND\n",
    "\n",
    "print(x.shape, y.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-05-03T21:23:16.776268Z",
     "start_time": "2023-05-03T21:23:16.765833Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step 0 cost: 3\n",
      "step 20 cost: 4\n",
      "step 40 cost: 4\n",
      "step 60 cost: 4\n",
      "step 80 cost: 4\n",
      "step 100 cost: 4\n",
      "w: [13.796494974356385, 0.993859200437837]\n",
      "b: -189.3948186286641\n",
      "y_pred: [-189.39481863 -188.40095943 -175.59832365 -174.60446445]\n"
     ]
    }
   ],
   "source": [
    "# seguindo as etapas do pseudo algoritmo\n",
    "\n",
    "# inicializando os pesos\n",
    "D = x.shape[1] # mesmo shape do número de features, ou seja, de entradas no perceptron\n",
    "w = [2 * random() -1 for i in range(D)] # coloando os valores dos pesos entre -1 e 1 com 2 * random() -1 \n",
    "b = 2 * random() -1\n",
    "learning_rate = 1.0\n",
    "  \n",
    "# para cada amostra, executando os calculos\n",
    "for step in range(101):\n",
    "    # inicializando custo\n",
    "    cost = 0\n",
    "    \n",
    "    for x_n, y_n in zip(x, y):\n",
    "        # predict\n",
    "        y_pred = sum([w_i * w_i for x_i, w_i in zip(x_n, w)])  + b\n",
    "\n",
    "        # step function\n",
    "        y_pred = 1 if y_pred > 0 else 0\n",
    "\n",
    "        # error\n",
    "        error = y_n - y_pred\n",
    "\n",
    "        # atualizando pesos e bias\n",
    "        w = [w_i + learning_rate * error * x_i for x_i, w_i in zip(x_n, w)]\n",
    "        b = b + learning_rate * error\n",
    "\n",
    "        # calculando custo para verificar aprendizado\n",
    "        cost += error ** 2\n",
    "\n",
    "    # plotando aprendizado a cada x passos\n",
    "    if step % 20 == 0:\n",
    "      print(f'step {step} cost: {cost}')\n",
    "  \n",
    "# plotando valores finais\n",
    "print(f'w: {w}')\n",
    "print(f'b: {b}')\n",
    "print('y_pred: {0}'.format(np.dot(x, np.array(w)) + b))        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-05-03T21:23:16.785315Z",
     "start_time": "2023-05-03T21:23:16.777201Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step 0: 0\n",
      "step 10: 0\n",
      "step 20: 0\n",
      "step 30: 0\n",
      "step 40: 0\n",
      "step 50: 1\n",
      "w: [ 0.22156636 -0.03022679]\n",
      "b: -0.1730544629791388\n",
      "y_pred: [-0.17305446 -0.20328125  0.04851189  0.0182851 ]\n"
     ]
    }
   ],
   "source": [
    "# inicializando pesos e bias\n",
    "D = x.shape[1] # n de colunas, atributos, features, entradas, etc.\n",
    "w = 2 * np.random.random(size = D) -1\n",
    "b = 2 * np.random.random() - 1\n",
    "learning_rate = 1e-2 # = 0.01\n",
    "\n",
    "# para cada amostra do banco\n",
    "for step in range(51):\n",
    "    for x_n, y_n in zip(x, y):\n",
    "        cost = 0\n",
    "        \n",
    "        # predict\n",
    "        y_pred = np.dot(x_n, w) + b\n",
    "\n",
    "        # funcao de ativacao\n",
    "        y_pred = np.where(y_pred > 0, 1, 0)\n",
    "\n",
    "        # calculo do erro\n",
    "        error = y_n - y_pred\n",
    "\n",
    "        # atualizando pesos e bias\n",
    "        w = w + learning_rate * np.dot(error, x_n) # multiplicando cada amostra pelo erro correspondente, vezes lr + w\n",
    "        b = b + learning_rate * error\n",
    "        \n",
    "        # atualizacao do custo\n",
    "        cost += error ** 2 # erro²\n",
    "        \n",
    "    # plotando o custo a cada x passos\n",
    "    if step % 10 == 0:\n",
    "        print('step {0}: {1}'.format(step, cost))\n",
    "\n",
    "# plotando valores finais\n",
    "print(f'w: {w}')\n",
    "print(f'b: {b}')\n",
    "print('y_pred: {0}'.format(np.dot(x, np.array(w)) + b))            "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Exercício de Classificação"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-05-03T21:23:16.876997Z",
     "start_time": "2023-05-03T21:23:16.785951Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(100, 2) (100,)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x7f1d23140a00>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x, y = make_blobs(n_samples=100, n_features=2, centers=2, random_state=1234)\n",
    "\n",
    "print(x.shape, y.shape)\n",
    "plt.scatter(x[:,0], x[:,1], c=y.ravel(), cmap='bwr')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-05-03T21:23:16.935251Z",
     "start_time": "2023-05-03T21:23:16.878159Z"
    }
   },
   "outputs": [],
   "source": [
    "def plot_linear_classifier(x, y, w, b):\n",
    "    x1_min, x1_max = x[:,0].min(), x[:,0].max()\n",
    "    x2_min, x2_max = x[:,1].min(), x[:,1].max()\n",
    "\n",
    "    x1, x2 = np.meshgrid(np.linspace(x1_min-1, x1_max+1,100), np.linspace(x2_min-1, x2_max+1, 100))\n",
    "    x_mesh = np.array([x1.ravel(), x2.ravel()]).T\n",
    "\n",
    "    plt.scatter(x[:,0], x[:,1], c=y.ravel(), cmap='bwr')\n",
    "\n",
    "    y_mesh = np.dot(x_mesh, np.array(w).reshape(1, -1).T) + b\n",
    "    y_mesh = np.where(y_mesh <= 0, 0, 1)\n",
    "\n",
    "    plt.contourf(x1, x2, y_mesh.reshape(x1.shape), cmap='bwr', alpha=0.5)\n",
    "    plt.xlim(x1_min-1, x1_max+1)\n",
    "    plt.ylim(x2_min-1, x2_max+1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-05-03T21:23:17.015315Z",
     "start_time": "2023-05-03T21:23:16.937131Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step 0 cost: 16\n",
      "step 10 cost: 0\n",
      "step 20 cost: 0\n",
      "step 30 cost: 0\n",
      "step 40 cost: 0\n",
      "step 50 cost: 0\n",
      "step 60 cost: 0\n",
      "step 70 cost: 0\n",
      "step 80 cost: 0\n",
      "step 90 cost: 0\n",
      "w: [0.32672323146088544, 0.2476014434729797]\n",
      "b: 0.3164690597569477\n"
     ]
    }
   ],
   "source": [
    "# seguindo as etapas do pseudo algoritmo\n",
    "\n",
    "# inicializando os pesos\n",
    "D = x.shape[1] # mesmo shape do número de features, ou seja, de entradas no perceptron\n",
    "w = [2 * random() -1 for i in range(D)] # coloando os valores dos pesos entre -1 e 1 com 2 * random() -1 \n",
    "b = 2 * random() -1\n",
    "learning_rate = 1e-2\n",
    "  \n",
    "# para cada amostra, executando os calculos\n",
    "for step in range(100):\n",
    "    # inicializando custo\n",
    "    cost = 0\n",
    "    \n",
    "    for x_n, y_n in zip(x, y):\n",
    "        # predict\n",
    "        y_pred = sum([x_i * w_i for x_i, w_i in zip(x_n, w)]) + b\n",
    "\n",
    "        # step function\n",
    "        y_pred = 1 if y_pred > 0 else 0\n",
    "\n",
    "        # error\n",
    "        error = y_n - y_pred\n",
    "\n",
    "        # atualizando pesos e bias\n",
    "        w = [w_i + learning_rate * error * x_i for x_i, w_i in zip(x_n, w)]\n",
    "        b = b + learning_rate * error\n",
    "\n",
    "        # calculando custo para verificar aprendizado\n",
    "        cost += error ** 2\n",
    "\n",
    "    # plotando aprendizado a cada x passos\n",
    "    if step % 10 == 0:\n",
    "      print(f'step {step} cost: {cost}')\n",
    "  \n",
    "# plotando valores finais\n",
    "print(f'w: {w}')\n",
    "print(f'b: {b}')\n",
    "#print('y_pred: {0}'.format(np.dot(x, np.array(w)) + b))        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-05-03T21:23:17.106203Z",
     "start_time": "2023-05-03T21:23:17.016478Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_linear_classifier(x, y, w, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-05-03T21:23:17.170944Z",
     "start_time": "2023-05-03T21:23:17.107119Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step 0: 0\n",
      "step 10: 0\n",
      "step 20: 0\n",
      "step 30: 0\n",
      "step 40: 0\n",
      "step 50: 0\n",
      "w: [0.58269692 0.77641873]\n",
      "b: -0.9204700364070622\n"
     ]
    }
   ],
   "source": [
    "# inicializando pesos e bias\n",
    "D = x.shape[1] # n de colunas, atributos, features, entradas, etc.\n",
    "w = 2 * np.random.random(size = D) -1\n",
    "b = 2 * np.random.random() - 1\n",
    "learning_rate = 1e-2 # = 0.01\n",
    "\n",
    "# para cada amostra do banco\n",
    "for step in range(51):\n",
    "    for x_n, y_n in zip(x, y):\n",
    "        cost = 0\n",
    "        \n",
    "        # predict\n",
    "        y_pred = np.dot(x_n, w) + b\n",
    "\n",
    "        # funcao de ativacao\n",
    "        y_pred = np.where(y_pred > 0, 1, 0)\n",
    "\n",
    "        # calculo do erro\n",
    "        error = y_n - y_pred\n",
    "\n",
    "        # atualizando pesos e bias\n",
    "        w = w + learning_rate * np.dot(error, x_n) # multiplicando cada amostra pelo erro correspondente, vezes lr + w\n",
    "        b = b + learning_rate * error\n",
    "        \n",
    "        # atualizacao do custo\n",
    "        cost += error ** 2 # erro²\n",
    "        \n",
    "    # plotando o custo a cada x passos\n",
    "    if step % 10 == 0:\n",
    "        print('step {0}: {1}'.format(step, cost))\n",
    "\n",
    "# plotando valores finais\n",
    "print(f'w: {w}')\n",
    "print(f'b: {b}')\n",
    "# print('y_pred: {0}'.format(np.dot(x, np.array(w)) + b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-05-03T21:23:17.273651Z",
     "start_time": "2023-05-03T21:23:17.173003Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_linear_classifier(x, y, w, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Regressão "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Para transformar o Perceptron em um __regressor linear__, só o que temos de fazer é __remover a função de ativação _step___, transformando-a em uma função de ativação linear.\n",
    "\n",
    "Apesar dessa modificação, __a fórmula de atualização dos pesos não sofre nenhuma alteração__. \n",
    "\n",
    "Vamos, então, implementar nosso perceptron para classificação em Python, Numpy, Keras e TensorFlow:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-05-03T21:23:17.290053Z",
     "start_time": "2023-05-03T21:23:17.274690Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(100, 2)\n"
     ]
    },
    {
     "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>Altura</th>\n",
       "      <th>Peso</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>187</td>\n",
       "      <td>109.72</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>177</td>\n",
       "      <td>91.09</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>180</td>\n",
       "      <td>88.93</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>177</td>\n",
       "      <td>89.39</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>177</td>\n",
       "      <td>92.02</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>183</td>\n",
       "      <td>94.70</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>178</td>\n",
       "      <td>83.57</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>177</td>\n",
       "      <td>85.19</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>183</td>\n",
       "      <td>92.96</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>188</td>\n",
       "      <td>108.21</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Altura    Peso\n",
       "0     187  109.72\n",
       "1     177   91.09\n",
       "2     180   88.93\n",
       "3     177   89.39\n",
       "4     177   92.02\n",
       "5     183   94.70\n",
       "6     178   83.57\n",
       "7     177   85.19\n",
       "8     183   92.96\n",
       "9     188  108.21"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.read_csv('data/medidas.csv')\n",
    "print(df.shape)\n",
    "df.head(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-05-03T21:23:17.389920Z",
     "start_time": "2023-05-03T21:23:17.291050Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Peso')"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = df.Altura.values\n",
    "y = df.Peso.values\n",
    "\n",
    "plt.figure()\n",
    "plt.scatter(x, y)\n",
    "plt.xlabel('Altura')\n",
    "plt.ylabel('Peso')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-05-03T21:23:17.392944Z",
     "start_time": "2023-05-03T21:23:17.390787Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(100,) (100,)\n"
     ]
    }
   ],
   "source": [
    "print(x.shape, y.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-05-03T21:23:17.397877Z",
     "start_time": "2023-05-03T21:23:17.393754Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(100, 1) (100,)\n"
     ]
    }
   ],
   "source": [
    "x = x.reshape(-1, 1)\n",
    "\n",
    "print(x.shape, y.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Exercício__: tentar estimar as learning_rates de **w** e __b__. Elas são diferentes por que nossos dados não estão na mesma escala!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-05-03T21:23:21.481629Z",
     "start_time": "2023-05-03T21:23:17.399007Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step 0: 99986.35855980792\n",
      "step 1000: 5195.20050084369\n",
      "step 2000: 3070.0713778389904\n",
      "step 3000: 2700.668823659674\n",
      "step 4000: 2637.6460211514973\n",
      "step 5000: 2627.3993316942474\n",
      "step 6000: 2625.9523005024603\n",
      "step 7000: 2625.847469278014\n",
      "step 8000: 2625.8919523873933\n",
      "step 9000: 2625.9262001117404\n",
      "step 10000: 2625.943315770699\n",
      "w:  [1.3697942978709434]\n",
      "b:  -157.88053772909623\n"
     ]
    }
   ],
   "source": [
    "D = x.shape[1]\n",
    "w = [2*random() - 1 for i in range(D)]\n",
    "b = 2*random() - 1\n",
    "\n",
    "for step in range(10001):\n",
    "    cost = 0\n",
    "    for x_n, y_n in zip(x, y):\n",
    "        # qual linha devemos remover para transformar o Perceptron num regressor?\n",
    "        y_pred = sum([x_i*w_i for x_i, w_i in zip(x_n, w)]) + b\n",
    "        #y_pred = 1 if y_pred > 0 else 0\n",
    "        error = y_n - y_pred\n",
    "        w = [w_i + 1e-7 *error*x_i for x_i, w_i in zip(x_n, w)]\n",
    "        b = b + 1e-2 * error\n",
    "        cost += error**2\n",
    "\n",
    "    if step%1000 == 0:\n",
    "        print('step {0}: {1}'.format(step, cost))\n",
    "\n",
    "print('w: ', w)\n",
    "print('b: ', b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Numpy "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-05-03T21:23:25.358569Z",
     "start_time": "2023-05-03T21:23:21.482660Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step 0: 683090.2983999851\n",
      "step 1000: 7237.135341875465\n",
      "step 2000: 3426.8476937302735\n",
      "step 3000: 2762.317663877253\n",
      "step 4000: 2648.0072592164224\n",
      "step 5000: 2629.016141017629\n",
      "step 6000: 2626.1498113337666\n",
      "step 7000: 2625.8456531003244\n",
      "step 8000: 2625.8762743043244\n",
      "step 9000: 2625.9169941599316\n",
      "step 10000: 2625.9389899687403\n",
      "w:  [1.3697286]\n",
      "b:  -157.86956381608272\n"
     ]
    }
   ],
   "source": [
    "D = x.shape[1]\n",
    "w = 2*np.random.random(size=D)-1\n",
    "b = 2*np.random.random()-1 \n",
    "\n",
    "for step in range(10001):\n",
    "    cost = 0\n",
    "    for x_n, y_n in zip(x, y):\n",
    "        # qual linha devemos remover para transformar o Perceptron num regressor?\n",
    "        y_pred = np.dot(x_n, w) + b \n",
    "        #y_pred = np.where(y_pred > 0, 1, 0)\n",
    "        error = y_n - y_pred\n",
    "        w = w + 1e-7 *np.dot(error, x_n)\n",
    "        b = b + 1e-2 *error\n",
    "        cost += error**2\n",
    "    \n",
    "    if step%1000 == 0:\n",
    "        print('step {0}: {1}'.format(step, cost))\n",
    "    \n",
    "print('w: ', w)\n",
    "print('b: ', b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Numpy com Pré-processamento"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-05-03T21:23:25.361815Z",
     "start_time": "2023-05-03T21:23:25.359297Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-1.0 0.9999999999999991\n"
     ]
    }
   ],
   "source": [
    "minmax = MinMaxScaler(feature_range=(-1,1))\n",
    "x = minmax.fit_transform(x.astype(np.float64))\n",
    "\n",
    "print(x.min(), x.max())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-05-03T21:23:25.373000Z",
     "start_time": "2023-05-03T21:23:25.362776Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "w:  [33.60164767]\n",
      "b:  74.99636286981102\n"
     ]
    }
   ],
   "source": [
    "reg = LinearRegression()\n",
    "reg.fit(x,y)\n",
    "\n",
    "print('w: ', reg.coef_)\n",
    "print('b: ', reg.intercept_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-05-03T21:23:25.749895Z",
     "start_time": "2023-05-03T21:23:25.374006Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step 0: 270689.61003857746\n",
      "step 100: 2629.0240932114157\n",
      "step 200: 2629.024092905569\n",
      "step 300: 2629.024092905569\n",
      "step 400: 2629.024092905569\n",
      "step 500: 2629.024092905569\n",
      "step 600: 2629.024092905569\n",
      "step 700: 2629.024092905569\n",
      "step 800: 2629.024092905569\n",
      "step 900: 2629.024092905569\n",
      "step 1000: 2629.024092905569\n",
      "w:  [33.54130144]\n",
      "b:  74.44004424754145\n"
     ]
    }
   ],
   "source": [
    "D = x.shape[1]\n",
    "w = 2*np.random.random(size=D)-1\n",
    "b = 2*np.random.random()-1 \n",
    "\n",
    "learning_rate = 1e-2 # <- tente estimar a learning_rate\n",
    "\n",
    "for step in range(1001):\n",
    "    cost = 0\n",
    "    for x_n, y_n in zip(x, y):\n",
    "        y_pred = np.dot(x_n, w) + b \n",
    "        error = y_n - y_pred\n",
    "        w = w + learning_rate*np.dot(error, x_n)\n",
    "        b = b + learning_rate*error\n",
    "        cost += error**2\n",
    "    \n",
    "    if step%100 == 0:\n",
    "        print('step {0}: {1}'.format(step, cost))\n",
    "    \n",
    "print('w: ', w)\n",
    "print('b: ', b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício de Regressão"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-05-03T21:23:25.761606Z",
     "start_time": "2023-05-03T21:23:25.751844Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(25, 4)\n"
     ]
    },
    {
     "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>prova1</th>\n",
       "      <th>prova2</th>\n",
       "      <th>prova3</th>\n",
       "      <th>final</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>73</td>\n",
       "      <td>80</td>\n",
       "      <td>75</td>\n",
       "      <td>152</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>93</td>\n",
       "      <td>88</td>\n",
       "      <td>93</td>\n",
       "      <td>185</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>89</td>\n",
       "      <td>91</td>\n",
       "      <td>90</td>\n",
       "      <td>180</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>96</td>\n",
       "      <td>98</td>\n",
       "      <td>100</td>\n",
       "      <td>196</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>73</td>\n",
       "      <td>66</td>\n",
       "      <td>70</td>\n",
       "      <td>142</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>53</td>\n",
       "      <td>46</td>\n",
       "      <td>55</td>\n",
       "      <td>101</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>69</td>\n",
       "      <td>74</td>\n",
       "      <td>77</td>\n",
       "      <td>149</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>47</td>\n",
       "      <td>56</td>\n",
       "      <td>60</td>\n",
       "      <td>115</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>87</td>\n",
       "      <td>79</td>\n",
       "      <td>90</td>\n",
       "      <td>175</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>79</td>\n",
       "      <td>70</td>\n",
       "      <td>88</td>\n",
       "      <td>164</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   prova1  prova2  prova3  final\n",
       "0      73      80      75    152\n",
       "1      93      88      93    185\n",
       "2      89      91      90    180\n",
       "3      96      98     100    196\n",
       "4      73      66      70    142\n",
       "5      53      46      55    101\n",
       "6      69      74      77    149\n",
       "7      47      56      60    115\n",
       "8      87      79      90    175\n",
       "9      79      70      88    164"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.read_csv('data/notas.csv')\n",
    "\n",
    "print(df.shape)\n",
    "df.head(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-05-03T21:23:25.939186Z",
     "start_time": "2023-05-03T21:23:25.762692Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Final')"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x288 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(20, 4))\n",
    "\n",
    "plt.subplot(1, 3, 1)\n",
    "plt.scatter(df.prova1.values, df.final.values)\n",
    "plt.xlabel('Prova 1')\n",
    "plt.ylabel('Final')\n",
    "\n",
    "plt.subplot(1, 3, 2)\n",
    "plt.scatter(df.prova2.values, df.final.values)\n",
    "plt.xlabel('Prova 2')\n",
    "plt.ylabel('Final')\n",
    "\n",
    "plt.subplot(1, 3, 3)\n",
    "plt.scatter(df.prova3.values, df.final.values)\n",
    "plt.xlabel('Prova 3')\n",
    "plt.ylabel('Final')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-05-03T21:23:25.947639Z",
     "start_time": "2023-05-03T21:23:25.940251Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(25, 3) (25,)\n"
     ]
    }
   ],
   "source": [
    "x = df[['prova1', 'prova2', 'prova3']].values\n",
    "y = df['final'].values\n",
    "\n",
    "print(x.shape, y.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-05-03T21:23:25.952416Z",
     "start_time": "2023-05-03T21:23:25.948304Z"
    }
   },
   "outputs": [],
   "source": [
    "minmax = MinMaxScaler(feature_range=(-1,1))\n",
    "x = minmax.fit_transform(x.astype(np.float64))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-05-03T21:23:25.957449Z",
     "start_time": "2023-05-03T21:23:25.953480Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "w:  [ 8.72048636 14.1054877  26.26749487]\n",
      "b:  150.65175754349872\n"
     ]
    }
   ],
   "source": [
    "reg = LinearRegression()\n",
    "reg.fit(x, y)\n",
    "\n",
    "print('w: ', reg.coef_)\n",
    "print('b: ', reg.intercept_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-05-03T21:23:26.089614Z",
     "start_time": "2023-05-03T21:23:25.958759Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step 0: 507236.7316372969\n",
      "step 200: 175.95651524464205\n",
      "step 400: 148.6365159191729\n",
      "step 600: 146.43517144663068\n",
      "step 800: 146.18550020391802\n",
      "w:  [8.800738077654112, 14.09217602971472, 26.290272082638374]\n",
      "b:  150.70697192708877\n"
     ]
    }
   ],
   "source": [
    "D = x.shape[1]\n",
    "w = [2*random() - 1 for i in range(D)]\n",
    "b = 2*random() - 1\n",
    "\n",
    "learning_rate = 0.01 # <- tente estimar a learning_rate\n",
    "\n",
    "for step in range(1000): # <- tente estimar o número de passos\n",
    "    cost = 0\n",
    "    for x_n, y_n in zip(x, y):\n",
    "        y_pred = sum([x_i*w_i for x_i, w_i in zip(x_n, w)]) + b\n",
    "        error = y_n - y_pred\n",
    "        w = [w_i + learning_rate*error*x_i for x_i, w_i in zip(x_n, w)]\n",
    "        b = b + learning_rate*error\n",
    "        cost += error**2\n",
    "        \n",
    "    if step%200 == 0:\n",
    "        print('step {0}: {1}'.format(step, cost))\n",
    "\n",
    "print('w: ', w)\n",
    "print('b: ', b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-05-03T21:23:26.241096Z",
     "start_time": "2023-05-03T21:23:26.090612Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step 0: 505513.6332687416\n",
      "step 200: 175.43830870581942\n",
      "step 400: 148.41772597285\n",
      "step 600: 146.40364256531686\n",
      "step 800: 146.1814239948911\n",
      "w:  [ 8.79626995 14.09515507 26.29189671]\n",
      "b:  150.70719686862157\n"
     ]
    }
   ],
   "source": [
    "D = x.shape[1]\n",
    "w = 2*np.random.random(size=D)-1\n",
    "b = 2*np.random.random()-1       \n",
    "\n",
    "learning_rate = 0.01 # <- tente estimar a learning_rate\n",
    "\n",
    "for step in range(1000): # <- tente estimar o número de passos\n",
    "    cost = 0\n",
    "    for x_n, y_n in zip(x, y):\n",
    "        y_pred = np.dot(x_n, w) + b \n",
    "        error = y_n - y_pred\n",
    "        w = w + learning_rate*np.dot(error, x_n)\n",
    "        b = b + learning_rate*error\n",
    "        cost += error**2\n",
    "    \n",
    "    if step%200 == 0:\n",
    "        print('step {0}: {1}'.format(step, cost))\n",
    "    \n",
    "print('w: ', w)\n",
    "print('b: ', b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Referências"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- [Artigo original do Perceptron](http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.335.3398&rep=rep1&type=pdf)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.6"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "313.711px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  },
  "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
}