notebooks/supervised/regression/intro.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "PUaIse1u4p0N"
   },
   "source": [
    "# Notas sobre *machine learning*: modelos lineares\n",
    "\n",
    "ML não é uma magia negra incompreensível. Não funciona pra todos os casos e não vai necessariamente te oferecer uma solução melhor do que uma implementação bem pensada e deterministica num passe de mágica. Tem as suas utilidades. Podemos resolver problemas de uma forma relativamente simples em ambientes dinâmicos e confusos, ou onde não podemos fazer grandes suposições em relação ao seu funcionamento.\n",
    "\n",
    "Esse notebook explica um pouco sobre modelos lineares: como eles funcionam e como utilizá-los de forma eficiente. Espero que seja instrutivo e clareie um pouco do tópico pra todo mundo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "kw8wwbsMI7S4"
   },
   "source": [
    "## Introdução\n",
    "\n",
    "Suponha que você é um dev em uma empresa de e-commerce de roupas e calçados.\n",
    "Ao longo dos meses de operação, a equipe coletou amostras para construir uma tabela que mapeia os tamanhos das peças para a altura média das pessoas que as compram, além de informações sobre sexo e tamanho dos sapatos dos compradores.\n",
    "\n",
    "A fim de fomentar o espirito consumista de seus clientes e impulsionar o ecosistema de blogueirinhas, você deseja recomendar belos calçados após cada compra de roupa. Naturalmente, você deseja recomendar somente os calçados que **provavelmente servirão** ao cliente específico."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cellView": "form",
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 72
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 2890,
     "status": "ok",
     "timestamp": 1598147572496,
     "user": {
      "displayName": "Lucas",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgO-xqdSSwbB8xXos7Shqhpq7QJ06mYVUvdLDRcbQ=s64",
      "userId": "01670254553878112810"
     },
     "user_tz": 180
    },
    "id": "NKy65_S_4p0P",
    "outputId": "8f024e15-e025-41a7-8cd0-a2afbe504ca7"
   },
   "outputs": [],
   "source": [
    "#@title\n",
    "\n",
    "import os\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import tensorflow as tf\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "import seaborn as sns\n",
    "from google.colab import drive"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cellView": "form",
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 124
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 38559,
     "status": "ok",
     "timestamp": 1598147634863,
     "user": {
      "displayName": "Lucas",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgO-xqdSSwbB8xXos7Shqhpq7QJ06mYVUvdLDRcbQ=s64",
      "userId": "01670254553878112810"
     },
     "user_tz": 180
    },
    "id": "cKOlw3EVGvcv",
    "outputId": "ed47c1fb-83cb-4bd6-ad00-dc817cabf5a6"
   },
   "outputs": [],
   "source": [
    "#@title\n",
    "\n",
    "from IPython.display import display_html\n",
    "def display_side_by_side(*args):\n",
    "    html_str=''\n",
    "    for df in args:\n",
    "        html_str+=df.to_html()\n",
    "    display_html(html_str.replace('table','table style=\"display:inline\"'),raw=True)\n",
    "\n",
    "drive.mount('/content/drive')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "c7AfUTAfKGWh"
   },
   "source": [
    "## Coletando as informações\n",
    "\n",
    "Conscientes do quão vagabundo você é, seus colegas disponibilizaram todos os dados necessários em um arquivo `wo_men.csv` (o [conjunto de dados wo-man](https://osf.io/66fvm/), na verdade), para leitura imediata:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "EDU2wwT94p0g"
   },
   "outputs": [],
   "source": [
    "DATA_FILE = '/content/drive/My Drive/Colab Notebooks/ml-notes/datasets/wo_men.csv'\n",
    "TRUSTED_FILE = '/content/drive/My Drive/Colab Notebooks/ml-notes/datasets/wo_men.trusted.csv'\n",
    "\n",
    "x = (pd.read_csv(DATA_FILE)\n",
    "     .drop(columns=['time'])\n",
    "     .dropna())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "0i2FaR2pwuYJ"
   },
   "source": [
    "Não precisamos da coluna de tempo, então podemos ler o arquivo e imediatamente removê-la. Apagamos também as linhas que contém valores faltantes. Procedemos então à exibir:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 206
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 1405,
     "status": "ok",
     "timestamp": 1598148212557,
     "user": {
      "displayName": "Lucas",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgO-xqdSSwbB8xXos7Shqhpq7QJ06mYVUvdLDRcbQ=s64",
      "userId": "01670254553878112810"
     },
     "user_tz": 180
    },
    "id": "qj8hOLOuwwqp",
    "outputId": "96e4709a-b2c6-4065-af99-e7b6cf209e6b"
   },
   "outputs": [],
   "source": [
    "x.head().round()  # as cinco primeiras linhas do conjunto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 112
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 874,
     "status": "ok",
     "timestamp": 1598148236437,
     "user": {
      "displayName": "Lucas",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgO-xqdSSwbB8xXos7Shqhpq7QJ06mYVUvdLDRcbQ=s64",
      "userId": "01670254553878112810"
     },
     "user_tz": 180
    },
    "id": "749rNq8IwZZ1",
    "outputId": "8f0bdca3-2993-4659-de88-7f93a0f9d40e"
   },
   "outputs": [],
   "source": [
    "x.describe().round().T  # estatísticas gerais sobre as colunas numéricas do conjunto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 143
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 709,
     "status": "ok",
     "timestamp": 1598148237334,
     "user": {
      "displayName": "Lucas",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgO-xqdSSwbB8xXos7Shqhpq7QJ06mYVUvdLDRcbQ=s64",
      "userId": "01670254553878112810"
     },
     "user_tz": 180
    },
    "id": "t5GeRsejwd7R",
    "outputId": "37244d39-a254-4116-fb03-5fad71333cee"
   },
   "outputs": [],
   "source": [
    "x.groupby('sex').count()  # a contagem de amostras para cada grupo da variável `sex`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "WPht5jTy4p0l"
   },
   "source": [
    "Observe que há muito mais amostras \"woman\" que \"man\".\n",
    "Isso pode criar um problema depois dependendo da tarefa a ser resolvida e o quão dependente ela é de *data-balancing* para performar corretamente.\n",
    "\n",
    "De qualquer forma, vamos primeiro nos preocupar em pre-processar esses dados."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "qoT-pg9w4p04"
   },
   "source": [
    "## *Data Engineering* & Análise\n",
    "\n",
    "Pra tomarmos (ou para a máquina tomar) decisões precisas, precisamos garantir que estes dados estejam o mais limpo possível. Como as colunas são estruturadas, podemos plotar alguns gráficos para explorá-las:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cellView": "form",
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 280
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 1328,
     "status": "ok",
     "timestamp": 1598148274315,
     "user": {
      "displayName": "Lucas",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgO-xqdSSwbB8xXos7Shqhpq7QJ06mYVUvdLDRcbQ=s64",
      "userId": "01670254553878112810"
     },
     "user_tz": 180
    },
    "id": "KO3oXh3t4p06",
    "outputId": "ed0ccbd8-a182-4777-ec12-2914230a60bf"
   },
   "outputs": [],
   "source": [
    "#@title\n",
    "\n",
    "with sns.axes_style('darkgrid'):\n",
    "    plt.figure(figsize=(16, 4))\n",
    "    plt.subplot(121)\n",
    "    sns.distplot(x.height)\n",
    "\n",
    "    plt.subplot(122)\n",
    "    sns.distplot(x.shoe_size);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "kAcrcmhS4p09"
   },
   "source": [
    "Algo esquisito está acontecendo:\n",
    "- 0.5% dos usuários tem a altura igual à $0$\n",
    "- alguns usuários possuem uma altura maior que $350cm$\n",
    "- alguns usuários calçam sapatos de tamanho próximo à 90\n",
    "\n",
    "Só pode ser um erro de entrada. Vamos visualizá-los separadamente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 175
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 1052,
     "status": "ok",
     "timestamp": 1598148551700,
     "user": {
      "displayName": "Lucas",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgO-xqdSSwbB8xXos7Shqhpq7QJ06mYVUvdLDRcbQ=s64",
      "userId": "01670254553878112810"
     },
     "user_tz": 180
    },
    "id": "ltnVnRIB4p0-",
    "outputId": "9bfe25f1-5bc0-4ccc-b07f-50e836e94aea"
   },
   "outputs": [],
   "source": [
    "x[x.height < 40]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "n3C3bgTc4p1C"
   },
   "source": [
    "Claramente, a altura foi escrita em *metros* em vez de *centímetros*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 81
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 1042,
     "status": "ok",
     "timestamp": 1598148551703,
     "user": {
      "displayName": "Lucas",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgO-xqdSSwbB8xXos7Shqhpq7QJ06mYVUvdLDRcbQ=s64",
      "userId": "01670254553878112810"
     },
     "user_tz": 180
    },
    "id": "9WPFo89l4p1D",
    "outputId": "57463ddb-9de4-4c7e-eaff-5e34f106123e"
   },
   "outputs": [],
   "source": [
    "x[x.height > 300]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "hFwd-ggX4p1I"
   },
   "source": [
    "Isso parece um erro irrecuperável. É melhor removermos essa linha completamente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "CFvGSTt34p1I"
   },
   "outputs": [],
   "source": [
    "def preprocessing(df):\n",
    "    y = df.copy()\n",
    "    y = handle_heights_in_cm(y)\n",
    "    y = drop_illegal_heights(y)\n",
    "    y = drop_illegal_shoe_sizes(y)\n",
    "\n",
    "    return y\n",
    "\n",
    "def drop_illegal_heights(df):\n",
    "    # Numbers based on the world-records\n",
    "    # for shortest and tallest person.\n",
    "    return df[(62.8 <= df.height) & (df.height <= 288)]\n",
    "\n",
    "def handle_heights_in_cm(df):\n",
    "    df[df.height <= 2.88] *= 100\n",
    "    return df\n",
    "\n",
    "def drop_illegal_shoe_sizes(df):\n",
    "    return df[df.shoe_size <= 75]\n",
    "\n",
    "x = preprocessing(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cellView": "form",
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 281
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 2101,
     "status": "ok",
     "timestamp": 1598148552786,
     "user": {
      "displayName": "Lucas",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgO-xqdSSwbB8xXos7Shqhpq7QJ06mYVUvdLDRcbQ=s64",
      "userId": "01670254553878112810"
     },
     "user_tz": 180
    },
    "id": "2SpxCjCS4p1N",
    "outputId": "0fea9f63-788c-4be1-ad96-2aa0cf9bdd13"
   },
   "outputs": [],
   "source": [
    "#@title\n",
    "\n",
    "with sns.axes_style('darkgrid'):\n",
    "    plt.figure(figsize=(16, 4))\n",
    "    plt.subplot(121)\n",
    "    sns.distplot(x.height)\n",
    "\n",
    "    plt.subplot(122)\n",
    "    sns.distplot(x.shoe_size);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 649
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 4453,
     "status": "ok",
     "timestamp": 1598148555151,
     "user": {
      "displayName": "Lucas",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgO-xqdSSwbB8xXos7Shqhpq7QJ06mYVUvdLDRcbQ=s64",
      "userId": "01670254553878112810"
     },
     "user_tz": 180
    },
    "id": "eKGJp87A4p1S",
    "outputId": "7eaf5d53-504e-4628-c664-9e6b9f54de74"
   },
   "outputs": [],
   "source": [
    "with sns.axes_style('darkgrid'):\n",
    "    plt.figure(figsize=(16, 4))\n",
    "    plt.subplot(121)\n",
    "    sns.boxplot(data=x, x='sex', y='height')\n",
    "\n",
    "    plt.subplot(122)\n",
    "    sns.boxplot(data=x, x='sex', y='shoe_size')\n",
    "\n",
    "    sns.pairplot(data=x, hue='sex');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "i_ejngSn4p1V"
   },
   "source": [
    "Isso significa que há uma clara distinção entre as alturas/tam. dos calçados de homens e mulheres, e eles podem ser variáveis importantes na hora de inferir a qual categoria uma amostra pertence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "N1kYQbGfKx3M"
   },
   "outputs": [],
   "source": [
    "x.to_csv(TRUSTED_FILE, index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "l5tJavjq4p1W"
   },
   "source": [
    "## Estimando o tamanho do calçado a partir da altura\n",
    "\n",
    "S: existe uma função $f\\star$ que descreve perfeitamente o relacionamento entre *tam. calçado* à outros atributos físicos, comportamentais e culturais de uma pessoa. Essa função com certeza depende de mais variáveis do que simplesmente a altura.\n",
    "\n",
    "Q: Podemos aproximar $f\\star$ tal que o erro mínimo associado $E$ é aceitável?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 5797,
     "status": "ok",
     "timestamp": 1598148556508,
     "user": {
      "displayName": "Lucas",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgO-xqdSSwbB8xXos7Shqhpq7QJ06mYVUvdLDRcbQ=s64",
      "userId": "01670254553878112810"
     },
     "user_tz": 180
    },
    "id": "ztxgz40X4p1X",
    "outputId": "87f37537-be68-4ad8-ebf8-274049cfdc02"
   },
   "outputs": [],
   "source": [
    "S = x.shoe_size.min(), x.shoe_size.max()\n",
    "S"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "BfAjntSQ4p1b"
   },
   "source": [
    "Podemos definir um estimador (determinístico) que diz diretamente qual é o valor para cada pessoa:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "-LYcPU0B4p1c"
   },
   "outputs": [],
   "source": [
    "def f(h):\n",
    "    return 36"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 5786,
     "status": "ok",
     "timestamp": 1598148556510,
     "user": {
      "displayName": "Lucas",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgO-xqdSSwbB8xXos7Shqhpq7QJ06mYVUvdLDRcbQ=s64",
      "userId": "01670254553878112810"
     },
     "user_tz": 180
    },
    "id": "p0RHuS2_4p1g",
    "outputId": "962976f2-8145-4430-b697-8683a6c99574"
   },
   "outputs": [],
   "source": [
    "_, h, s = x.iloc[0]\n",
    "p = f(h)\n",
    "\n",
    "E = np.abs(s - p)\n",
    "s, p, E"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "CN3pCwpf4p1j"
   },
   "source": [
    "Considerando uma das amostras do conjunto (a primeira), é possível medir (baseado em alguma função de erro) o *quão distante estamos* da saída desejada (o tam. do calçado verdadeiro). Erros grandes significam maiores distancias para o valor desejado, enquanto erros baixos implicam em estimadores mais acurados. Vamos chamar a função que usamos acima *absolute error function*:\n",
    "\n",
    "$$E(h, s) = |s - f(h)|$$\n",
    "\n",
    "Mas considerar somente a primeira amostra é representativo o suficiente? Construir modelos genéricos baseados em uma única observação é muito selvagem.\n",
    "É melhor olharamos pra todo o conjunto de dados:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 206
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 5777,
     "status": "ok",
     "timestamp": 1598148556511,
     "user": {
      "displayName": "Lucas",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgO-xqdSSwbB8xXos7Shqhpq7QJ06mYVUvdLDRcbQ=s64",
      "userId": "01670254553878112810"
     },
     "user_tz": 180
    },
    "id": "ESRAMcsF4p1q",
    "outputId": "e77550b3-9837-40e1-dbf1-a5afcea38efe"
   },
   "outputs": [],
   "source": [
    "def predict(x, fn):\n",
    "    x = x.copy()\n",
    "    x['predicted'] = [fn(h) for h in x.height]\n",
    "    x['error'] = np.abs(x.predicted - x.shoe_size)\n",
    "    return x\n",
    "\n",
    "predict(x, f).head().round(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "LlKsT5XK4p1u"
   },
   "source": [
    "Se calcularmos a *média* entre todos os *absolute errors* (alcançando a função *mae*), se torna claro que nossas \"predições\" estão fora do esperado por mais ou menos $3.33$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 300
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 5769,
     "status": "ok",
     "timestamp": 1598148556512,
     "user": {
      "displayName": "Lucas",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgO-xqdSSwbB8xXos7Shqhpq7QJ06mYVUvdLDRcbQ=s64",
      "userId": "01670254553878112810"
     },
     "user_tz": 180
    },
    "id": "bd5d_6ID4p1v",
    "outputId": "9f57f17f-788d-4e09-dddb-2d3492764730"
   },
   "outputs": [],
   "source": [
    "predict(x, f).describe().round(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "fAbPfFIC4p1y"
   },
   "source": [
    "Observando a tabela acima, a função pode ser trivialmente ajustada para reduzir o erro para $2$. Consegue imaginar como?\n",
    "\n",
    "Pensa um pouquinho antes de exibir o código abaixo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cellView": "form",
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 300
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 5760,
     "status": "ok",
     "timestamp": 1598148556514,
     "user": {
      "displayName": "Lucas",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgO-xqdSSwbB8xXos7Shqhpq7QJ06mYVUvdLDRcbQ=s64",
      "userId": "01670254553878112810"
     },
     "user_tz": 180
    },
    "id": "9V9gI9yZ4p10",
    "outputId": "e4d46791-1865-4619-8293-d4eb933cd046"
   },
   "outputs": [],
   "source": [
    "#@title\n",
    "\n",
    "def f(h):\n",
    "    return 39.31  # populational mean\n",
    "\n",
    "predict(x, f).describe().round(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "X19vRxBqPROY"
   },
   "source": [
    "A média populacional é o valor que produz o menor *mae*, pela definição de esperança e como a *mae* é definida, mas a média dos erros é suficiente pra descrever como está o nosso modelo?\n",
    "\n",
    "As distribuições de *tam. de calçados* verdadeira (normalmente chamada de *ground truth*) e das nossas predições podem oferecer um pouco mais de contexto:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cellView": "both",
    "colab": {},
    "colab_type": "code",
    "id": "VgTAnSOHQbvP"
   },
   "outputs": [],
   "source": [
    "from sklearn import metrics\n",
    "\n",
    "def evaluate(y, p):\n",
    "    print('MAE:', metrics.mean_absolute_error(y, p).round(3))\n",
    "\n",
    "    with sns.axes_style('darkgrid'):\n",
    "        plt.figure(figsize=(9, 3))\n",
    "        plt.subplot(121)\n",
    "        plt.title('Observations and Predictions Distribution')\n",
    "        sns.distplot(y, label='ground truth')\n",
    "        sns.distplot(p, label='predicted')\n",
    "        plt.legend();\n",
    "\n",
    "        plt.subplot(122)\n",
    "        plt.title('Error Distribution')\n",
    "        sns.distplot(np.abs(y - p), label='error', kde=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 328
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 6384,
     "status": "ok",
     "timestamp": 1598148557150,
     "user": {
      "displayName": "Lucas",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgO-xqdSSwbB8xXos7Shqhpq7QJ06mYVUvdLDRcbQ=s64",
      "userId": "01670254553878112810"
     },
     "user_tz": 180
    },
    "id": "ekF81PYr4p13",
    "outputId": "aa3f1517-fe01-439b-c359-8111ad6582b8"
   },
   "outputs": [],
   "source": [
    "p = predict(x, f)\n",
    "\n",
    "evaluate(p.shoe_size, p.predicted)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "jx-AokIh4p16"
   },
   "source": [
    "Note que nunca iremos predizer bem para pessoas que possuem o tam. do calçado diferente da média (todo mundo, de acordo com o gráfico abaixo).\n",
    "\n",
    "O segundo gráfico ilustra a partir de uma sequência de diferenças entre valores preditos e variáveis alvo. A maioria dos erros de concentram abaixo de 2 ou 3 números.\n",
    "\n",
    "O que aconteceria se colocassemos um pouco de variação no nosso modelo? O erro iria aumentar ou diminuir?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 300
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 6374,
     "status": "ok",
     "timestamp": 1598148557150,
     "user": {
      "displayName": "Lucas",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgO-xqdSSwbB8xXos7Shqhpq7QJ06mYVUvdLDRcbQ=s64",
      "userId": "01670254553878112810"
     },
     "user_tz": 180
    },
    "id": "V21RajWn4p17",
    "outputId": "960a9961-17e5-408c-9bad-895391046f6f"
   },
   "outputs": [],
   "source": [
    "def f(h):\n",
    "    return 39.31 + np.random.randn() * 1.84\n",
    "\n",
    "predict(x, f).describe().round(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "cflcpUoG4p1-"
   },
   "source": [
    "O erro médio subiu um pouco, mas não tenho certeza se isso é significativo. As distribuições, entretanto, estão muito mais parecidas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 258
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 7234,
     "status": "ok",
     "timestamp": 1598148558021,
     "user": {
      "displayName": "Lucas",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgO-xqdSSwbB8xXos7Shqhpq7QJ06mYVUvdLDRcbQ=s64",
      "userId": "01670254553878112810"
     },
     "user_tz": 180
    },
    "id": "UCltDmPb4p1_",
    "outputId": "be203a2c-d826-4f35-e6a4-3a1608e23ad6"
   },
   "outputs": [],
   "source": [
    "p = predict(x, f)\n",
    "\n",
    "evaluate(p.shoe_size, p.predicted)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "KzHkDcBv4p2C"
   },
   "source": [
    "Nós ainda estamos muito ruins (pior do que antes) em predizer a variável de interesse para pessoas com pés anormais, mas agora podemos fingir que o nosso modelo é inteligente (ou ao menos **não determinístico**).\n",
    "\n",
    "O segundo gráfico nos diz que ainda estamos fazendo mais erros pequenos do que grandes, mas que no geral mais erros grandes acontecem agora que adicionamos o fator aleatório `np.random.randn`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "22VTRh2kRXue"
   },
   "source": [
    "Os modelos acima utilizam informações estatísticas para criar uma resposta. Isso seria argumentavelmente uma decisão \"racional\", mas isso seria considerado \"machine learning\"?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "iFceMSVd4p2D"
   },
   "source": [
    "### Aprendendo parâmetros\n",
    "\n",
    "Como podemos melhorar ainda mais nossas estimativas?\n",
    "Até agora, nós temos uma função estimadora *constante* e uma função de cálculo de erro. A próxima função mais simples é a função linear:\n",
    "\n",
    "$$f(x) = ax + b$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "CpHrpUyPS3wa"
   },
   "source": [
    "#### Estudo sobre variáveis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "a4v4bGxe4p2D"
   },
   "outputs": [],
   "source": [
    "def f(h, a, b):\n",
    "    return a*h + b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "XKteXVpn4p2G"
   },
   "source": [
    "Essa função assume vários comportamentos dependendo dos parâmetros $a$ e $b$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 279
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 1552,
     "status": "ok",
     "timestamp": 1598148685001,
     "user": {
      "displayName": "Lucas",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgO-xqdSSwbB8xXos7Shqhpq7QJ06mYVUvdLDRcbQ=s64",
      "userId": "01670254553878112810"
     },
     "user_tz": 180
    },
    "id": "5CTDx4v84p2G",
    "outputId": "02b36a08-b195-40bf-ef13-0b994e6e2f5b"
   },
   "outputs": [],
   "source": [
    "with sns.axes_style('darkgrid'):\n",
    "    sns.scatterplot(data=x, x='height', y='shoe_size',\n",
    "                    hue='sex',\n",
    "                    label='real data')\n",
    "\n",
    "    for a, b in ((.08, 17),\n",
    "                (.25, 0),\n",
    "                (.07, 20)):\n",
    "        h = 150 + np.arange(80)\n",
    "        p = f(h, a, b)\n",
    "        \n",
    "        sns.lineplot(h, p, label=f'f={a}x + {b}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "RRYLior04p2K"
   },
   "source": [
    "Existe uma linha $(a, b)$ que estima perfeitamente a variável alvo em cima da característica de entrada? Pela figura, com certeza não: as amostras não são colineares. Qual é a melhor linha então?\n",
    "\n",
    "Se todas as $n$ amostras têm a mesma **importância**, então nós queremos estimar todas elas o melhor possível. Com `MAE` como função de erro, podemos **escolher** parâmetros $a, b$ tais que essa métrica atinja um valor mínimo.\n",
    "\n",
    "Em outras palavras, treinar o modelo.  \n",
    "Em outras outras palavras:\n",
    "\n",
    "$$argmin_{a, b} \\frac{1}{n} \\sum_i^{n} |y_i - f_i| $$\n",
    "\n",
    "Onde $f_i = ah_i + b$.\n",
    "\n",
    "Só que existe um problema aqui: a função norma não é suave e imediatamente diferenciável:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "0FRACe1UItOv"
   },
   "outputs": [],
   "source": [
    "def mae_loss(y, p):\n",
    "    return np.abs(y - p).mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cellView": "form",
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 211
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 7952,
     "status": "ok",
     "timestamp": 1598148558760,
     "user": {
      "displayName": "Lucas",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgO-xqdSSwbB8xXos7Shqhpq7QJ06mYVUvdLDRcbQ=s64",
      "userId": "01670254553878112810"
     },
     "user_tz": 180
    },
    "id": "0j8tZAuJ4p2N",
    "outputId": "8dadcbae-bdd2-4f33-de65-6815c2f5d658"
   },
   "outputs": [],
   "source": [
    "#@title\n",
    "\n",
    "with sns.axes_style('darkgrid'):\n",
    "    plt.figure(figsize=(5, 3))\n",
    "\n",
    "    p = np.arange(101) -50\n",
    "    sns.lineplot(p, np.abs(p));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "XXGUnFNX4p2R"
   },
   "source": [
    "Isso não é exatamente um problema nesse caso onde uma única variável está sendo otimizada, mas causa a criação de muitos pontos não-diferenciaveis em problemas que dependem de múltiplas características, o que torna o processo de otimização instável.\n",
    "\n",
    "Proposta: porque não substituímos pela função de otimização quadrática? Isso irá curvar a linha próximo ao 0.\n",
    "\n",
    "O modelo então se torna:\n",
    "$$argmin_{a, b} \\frac{1}{n}\\sum_i^{n} (y_i - p_i)^2 $$\n",
    "\n",
    "Essa função é uma cremosa diferenciável."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ZfFNUanv4p2R"
   },
   "outputs": [],
   "source": [
    "def mse_loss(y, p):\n",
    "    return ((y - p) ** 2).mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cellView": "form",
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 211
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 8321,
     "status": "ok",
     "timestamp": 1598148559140,
     "user": {
      "displayName": "Lucas",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgO-xqdSSwbB8xXos7Shqhpq7QJ06mYVUvdLDRcbQ=s64",
      "userId": "01670254553878112810"
     },
     "user_tz": 180
    },
    "id": "dAxTiuyv4p2T",
    "outputId": "9a29abb8-9b0f-4171-df60-058a52564121"
   },
   "outputs": [],
   "source": [
    "#@title\n",
    "\n",
    "with sns.axes_style('darkgrid'):\n",
    "    plt.figure(figsize=(5, 3))\n",
    "\n",
    "    p = np.arange(101) -50\n",
    "    sns.lineplot(p, p ** 2);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "TagAEYKc4p2X"
   },
   "source": [
    "Mas é claro, nós temos dois parâmetros, então o nosso espaço de busca se parece muito mais com isso:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "KUU-ASeg4p2X"
   },
   "outputs": [],
   "source": [
    "As = np.linspace(-10, 10, 40)\n",
    "Bs = np.linspace(-1000, 1000, 100)\n",
    "\n",
    "# Generate many combinations of (a, b)\n",
    "aa, bb = np.meshgrid(As, Bs)\n",
    "ab = np.asarray([aa.ravel(), bb.ravel()]).T\n",
    "\n",
    "# Compute the loss for each combination\n",
    "mse = [mse_loss(x.shoe_size, f(x.height, a, b))\n",
    "       for a, b in ab]\n",
    "\n",
    "space = np.hstack((ab, np.asarray(mse).reshape(-1, 1)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 297
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 13022,
     "status": "ok",
     "timestamp": 1598148563854,
     "user": {
      "displayName": "Lucas",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgO-xqdSSwbB8xXos7Shqhpq7QJ06mYVUvdLDRcbQ=s64",
      "userId": "01670254553878112810"
     },
     "user_tz": 180
    },
    "id": "ln8KS3dd4p2Z",
    "outputId": "d1e37126-bc35-4741-b259-8362fe07b776"
   },
   "outputs": [],
   "source": [
    "ax = plt.gca(projection='3d')\n",
    "ax.plot_trisurf(space[:, 0], space[:, 1], space[:, 2], cmap=plt.cm.viridis)\n",
    "ax.set_xlabel('a'), ax.set_ylabel('b'), ax.set_zlabel('MSE')\n",
    "ax.view_init(30, -50)\n",
    "plt.tight_layout();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "YGAzVLRW4p2c"
   },
   "source": [
    "De qualquer forma, para propósito de ilustração, vamos voltar ao nosso cenário com uma única variável (suponha $b = 0$) a ser refinada. Podemos começar em um ponto aleatório no espaço:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 180253,
     "status": "ok",
     "timestamp": 1598020441907,
     "user": {
      "displayName": "Lucas",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgO-xqdSSwbB8xXos7Shqhpq7QJ06mYVUvdLDRcbQ=s64",
      "userId": "01670254553878112810"
     },
     "user_tz": 180
    },
    "id": "SMRUeGLe4p2c",
    "outputId": "7554f6e6-3e25-49b0-d3aa-f9e98d90dd36"
   },
   "outputs": [],
   "source": [
    "a0 = 1 + .25 * np.random.randn()\n",
    "b0 = 0\n",
    "f0 = f(x.height[0], a0, b0)\n",
    "mse0 = mse_loss(x.shoe_size, f(x.height, a0, b0))\n",
    "\n",
    "a0, b0, f0, mse0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cellView": "form",
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 180251,
     "status": "ok",
     "timestamp": 1598020441909,
     "user": {
      "displayName": "Lucas",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgO-xqdSSwbB8xXos7Shqhpq7QJ06mYVUvdLDRcbQ=s64",
      "userId": "01670254553878112810"
     },
     "user_tz": 180
    },
    "id": "q90pY3cS4p2f",
    "outputId": "3fabc8da-ea95-4646-a6be-1f9ba942a9c8"
   },
   "outputs": [],
   "source": [
    "#@title\n",
    "\n",
    "def point_on_curve(e, a, b):\n",
    "    plt.plot([a], [e], 'o')\n",
    "    plt.annotate(f'mse(${a:.1f}h + {b})$',\n",
    "                 xy=(a, e),\n",
    "                 xytext=(a + .1, e));\n",
    "\n",
    "As = np.linspace(-2, 2, 20)\n",
    "mses = [mse_loss(x.shoe_size, f(x.height, ax, b0)) for ax in As]\n",
    "\n",
    "with sns.axes_style('darkgrid'):\n",
    "    plt.figure(figsize=(5, 3))\n",
    "    sns.lineplot(As, mses)\n",
    "    point_on_curve(mse0, a0, b0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "bg7l2Sde4p2i"
   },
   "source": [
    "#### Solução exata da equação\n",
    "\n",
    "Se $a$ crescer, o `mse` aumenta quadraticamente.\n",
    "O ponto ótimo $a\\star$ é no intervalo $(0, 1)$, tal que o `mse` é mínimo.\n",
    "\n",
    "$model = argmin_{a}\\frac{1}{n} \\sum_i (y_i - p_i)^2 = argmin_{a} \\frac{1}{n}\\sum_i y_i - (ah_i + b)^2$\n",
    "\n",
    "Essa equação só tem um ponto crítico, então tem solução imediata:\n",
    "\n",
    "$\\frac{\\partial mse}{\\partial a} = 0$  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "svdIe7D-B-Ds"
   },
   "source": [
    "Expandindo a derivada acima:\n",
    "\n",
    "$\\frac{\\partial}{\\partial a} \\frac{1}{n}\\sum_i (y_i -ah_i -b)^2 $  \n",
    "$= \\frac{1}{n}\\sum_i \\frac{\\partial mse}{\\partial a} (y_i - ah_i -b)^2$  \n",
    "$= \\frac{2}{n}\\sum_i (y_i - ah_i -b)\\frac{\\partial}{\\partial a} (y_i - ah_i -b)$  \n",
    "$= \\frac{2}{n}\\sum_i (y_i - ah_i -b)h_i$  \n",
    "$= \\frac{2}{n}\\sum_i y_ih_i - ah_i^2 -bh_i = 0$  \n",
    "$\\implies$  \n",
    "$\\frac{2}{n}\\sum_i y_ih_i -bh_i = \\frac{2}{n}\\sum_i ah_i^2$  \n",
    "$\\implies$  \n",
    "$a\\star = \\frac{2}{n}\\sum_i \\frac{y_ih_i bh_i}{h_i^2} = \\frac{2}{n}\\sum_i \\frac{y_i -b}{h_i}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "T1J8YodaQ4Uy"
   },
   "source": [
    "**Observação 1:** se tivéssemos o segundo parâmetro $b$ livre, poderíamos buscá-lo da mesma forma:\n",
    "\n",
    "$b\\star = \\frac{1}{2n}\\sum_i y_i - ah_i$\n",
    "\n",
    "**Observação 2:** já que o `mse` não tem uma interpretação humana direta de qualquer jeito (igual ao `mae`), uma conveniência matemática é normalmente adotada onde ela é definida dividida por $2$:\n",
    "\n",
    "$mse(y, p) = \\frac{1}{2n}\\sum_i^n (...)^2$\n",
    "\n",
    "Isso simplifica as derivadas:\n",
    "\n",
    "$a\\star = \\frac{1}{n}\\sum_i \\frac{y_i -b}{h_i}$  \n",
    "$b\\star = \\frac{1}{n}\\sum_i y_i - ah_i$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 180717,
     "status": "ok",
     "timestamp": 1598020442379,
     "user": {
      "displayName": "Lucas",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgO-xqdSSwbB8xXos7Shqhpq7QJ06mYVUvdLDRcbQ=s64",
      "userId": "01670254553878112810"
     },
     "user_tz": 180
    },
    "id": "2lPA6OX_LUBu",
    "outputId": "24cf5adf-1358-4715-9bb7-fdbac0cdb17b"
   },
   "outputs": [],
   "source": [
    "a1 = ((x.shoe_size - b0) / x.height).mean()\n",
    "mse1 = mse_loss(x.shoe_size, f(x.height, a1, b0))\n",
    "\n",
    "print('MSE:', mse1)\n",
    "\n",
    "plt.figure(figsize=(5, 3))\n",
    "sns.lineplot(As, mses)\n",
    "point_on_curve(mse1, a1, b0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "IdYGbWtYOmZ3"
   },
   "source": [
    "A reta $(a_1, 0)$ pode agora ser utilizada para estimar novas amostras com tamanho de sapato desconhecido, contando que a informação de altura esteja disponível:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 181494,
     "status": "ok",
     "timestamp": 1598020443161,
     "user": {
      "displayName": "Lucas",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgO-xqdSSwbB8xXos7Shqhpq7QJ06mYVUvdLDRcbQ=s64",
      "userId": "01670254553878112810"
     },
     "user_tz": 180
    },
    "id": "o8aY3LUJOzEl",
    "outputId": "1d41effe-e26c-43f6-ad48-7567031a8cac"
   },
   "outputs": [],
   "source": [
    "sns.scatterplot(data=x, x='height', y='shoe_size',\n",
    "                hue='sex',\n",
    "                label='real data')\n",
    "\n",
    "h = 150 + np.arange(80)\n",
    "p = f(h, a1, b0)\n",
    "sns.lineplot(h, p, label=f'f={a1}x + {b0}');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "-zOUJfzsSz4z"
   },
   "source": [
    "Podemos otimizar os dois parâmetros e atingir um resultado melhor:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 181494,
     "status": "ok",
     "timestamp": 1598020443165,
     "user": {
      "displayName": "Lucas",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgO-xqdSSwbB8xXos7Shqhpq7QJ06mYVUvdLDRcbQ=s64",
      "userId": "01670254553878112810"
     },
     "user_tz": 180
    },
    "id": "utqbcO0nS73d",
    "outputId": "a2802272-942c-43b0-bd7f-498b6008075c"
   },
   "outputs": [],
   "source": [
    "b1 = (x.shoe_size - a1*x.height).mean()\n",
    "mse2 = mse_loss(x.shoe_size, f(x.height, a1, b1))\n",
    "\n",
    "print(f'MSE updated from {mse1} to {mse2} by optimizing parameter b.')\n",
    "\n",
    "plt.figure(figsize=(5, 3))\n",
    "sns.lineplot(As, mses)\n",
    "point_on_curve(mse2, a1, b1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ozrOtvzNh6a6"
   },
   "source": [
    "Esse processo de treinamento é interessante por ser eficiente, mas exige que os as variáveis de entrada sejam diferentes de $0$. Quando múltiplas características são apresentadas, essa exigência se generaliza em esperar que a matriz seja inversível.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "NiccmK0n_dh_"
   },
   "source": [
    "#### Solução iterativa da equação\n",
    "\n",
    "\n",
    "Uma outra forma de definir o treinamento é como um processo de **otimização iterativo**, onde todos os parâmetros são sujeitos a uma regra de atualização amortecida por um coeficiente (*learning rate*) por um número limitado de passos (*epochs*)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Z0sMC97M4p2j"
   },
   "source": [
    "### Regressões lineares eficientes utilizando o Scikit-learn\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "1Czvdmdq4p2j"
   },
   "outputs": [],
   "source": [
    "from sklearn import metrics\n",
    "from sklearn.linear_model import LinearRegression\n",
    "\n",
    "FEATURES = ['height']\n",
    "\n",
    "model = LinearRegression().fit(x[FEATURES], x.shoe_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 263
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 182640,
     "status": "ok",
     "timestamp": 1598020444317,
     "user": {
      "displayName": "Lucas",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgO-xqdSSwbB8xXos7Shqhpq7QJ06mYVUvdLDRcbQ=s64",
      "userId": "01670254553878112810"
     },
     "user_tz": 180
    },
    "id": "Ry8RuQjJ4p2l",
    "outputId": "c1f101c6-e952-4896-915a-47936d0f2bc8"
   },
   "outputs": [],
   "source": [
    "predicted = model.predict(x[FEATURES])\n",
    "\n",
    "evaluate(x.shoe_size, predicted)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "E2Uw9TgwEzuR"
   },
   "source": [
    "**Para pensar:** a derivada igualada à $0$ não nos dá o ponto ótimo de uma função? Como é possível para o regressor logístico do scikit encontrar uma solução melhor que a nossa?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "0BhBo7VqXL-j"
   },
   "source": [
    "Após otimizar os parâmetros $a, b$, nosso erro caiu **muito**. Eles estão agora majoritariamente concentrados no intervalo $(0, 1.5)$.\n",
    "\n",
    "Os parâmetros do modelo treinado no scikit-learn tb podem ser diretamente acessados:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 182640,
     "status": "ok",
     "timestamp": 1598020444324,
     "user": {
      "displayName": "Lucas",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgO-xqdSSwbB8xXos7Shqhpq7QJ06mYVUvdLDRcbQ=s64",
      "userId": "01670254553878112810"
     },
     "user_tz": 180
    },
    "id": "aCysZN4YeMax",
    "outputId": "011c9f53-3e3b-4026-d6bf-6ef3ad3605f7"
   },
   "outputs": [],
   "source": [
    "model.coef_, model.intercept_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Blcz6UWqrHie"
   },
   "source": [
    "Os coeficientes angulares são representados como um vetor pois o scikit considera múltiplas características estão sendo entregues (embora no nosso caso tenha sido uma lista com uma única)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 289
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 183097,
     "status": "ok",
     "timestamp": 1598020444789,
     "user": {
      "displayName": "Lucas",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgO-xqdSSwbB8xXos7Shqhpq7QJ06mYVUvdLDRcbQ=s64",
      "userId": "01670254553878112810"
     },
     "user_tz": 180
    },
    "id": "oVlaAg1ceuWz",
    "outputId": "d0211166-98d8-44de-f3dc-eb56cbad58ca"
   },
   "outputs": [],
   "source": [
    "sns.scatterplot(data=x, x='height', y='shoe_size',\n",
    "                hue='sex',\n",
    "                label='real data')\n",
    "\n",
    "h = 150 + np.arange(80)\n",
    "a = model.coef_\n",
    "b = model.intercept_\n",
    "p = f(h, a, b)\n",
    "sns.lineplot(h, p, label=f'f={a.round(1)}h + {b.round(1)}');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "GoHX9VQFfSTG"
   },
   "source": [
    "Perfeita, não é?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ni7T6tnjc-Oo"
   },
   "source": [
    "#### Enriquecendo a informação do *dataset*\n",
    "\n",
    "Podemos enriquecer o estimador ao adicionar mais características.  \n",
    "Isso aumenta o número de coeficientes utilizados, a granularidade da decisão e, possívelmente, o torna mais acurado:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 225
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 183091,
     "status": "ok",
     "timestamp": 1598020444790,
     "user": {
      "displayName": "Lucas",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgO-xqdSSwbB8xXos7Shqhpq7QJ06mYVUvdLDRcbQ=s64",
      "userId": "01670254553878112810"
     },
     "user_tz": 180
    },
    "id": "o4Jyh-o3c0R-",
    "outputId": "f9947d10-6b51-4ce2-8d1c-68b358ee8f57"
   },
   "outputs": [],
   "source": [
    "import traceback\n",
    "\n",
    "try:\n",
    "    model = LinearRegression().fit(x[['height', 'sex']], x.shoe_size)\n",
    "except ValueError as e:\n",
    "    traceback.print_exc()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "BrYzT8StduUG"
   },
   "source": [
    "Por ser um modelo geométrico, ele espera que as features pertençam ao conjunto Real.\n",
    "Uma forma de lidar com isso é codificando os rótulos em inteiros:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 206
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 183085,
     "status": "ok",
     "timestamp": 1598020444792,
     "user": {
      "displayName": "Lucas",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgO-xqdSSwbB8xXos7Shqhpq7QJ06mYVUvdLDRcbQ=s64",
      "userId": "01670254553878112810"
     },
     "user_tz": 180
    },
    "id": "A68XTAjAioMW",
    "outputId": "26839883-f4cc-4d40-9ee3-630f56c09824"
   },
   "outputs": [],
   "source": [
    "x['sex_encoded'] = (x.sex == 'woman').astype(int)\n",
    "x.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "UabWYQQzi25Y"
   },
   "source": [
    "Porque a variável sexo é binária neste conjunto (`woman` e `man`), ela codifica nos valores 0 e 1. Isso é preprocessamento suficiente para o nosso modelo. Nós estamos usando aqui o que os estatísticos chamam de suposição de `efeito fixo`: a variável categória exerce uma influencia fixa (constante) sobre a variável observada.\n",
    "\n",
    "**Em outras palavras:** estamos criando um modelo que estima o tamanho de sapatos de homens e então adiciona um fator (aprendido) fixo sobre a resposta para estimar o sapatos das mulheres."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ExvmM5S2klea"
   },
   "source": [
    "Um jeito mais fácil de codificar *labels* e mantê-las consistentes ao longo de múltiplas execuções é utilizando um [label encoder](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.LabelEncoder.html). Neste caso, ele performa exatamente como o nosso código acima:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 206
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 183079,
     "status": "ok",
     "timestamp": 1598020444794,
     "user": {
      "displayName": "Lucas",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgO-xqdSSwbB8xXos7Shqhpq7QJ06mYVUvdLDRcbQ=s64",
      "userId": "01670254553878112810"
     },
     "user_tz": 180
    },
    "id": "npwutTSOhuNQ",
    "outputId": "8aed5f2b-4c65-4ba6-a777-600e8a06afd2"
   },
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import LabelEncoder\n",
    "\n",
    "le = LabelEncoder()\n",
    "x['sex_encoded'] = le.fit_transform(x.sex)\n",
    "\n",
    "# joblib.dump(e, '/path/le.p')\n",
    "# e.transform(...)  # then during test, production inference...\n",
    "\n",
    "x.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "r2IwMZ06ieHq"
   },
   "source": [
    "Retreinando e avaliando:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 263
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 1304,
     "status": "ok",
     "timestamp": 1598020473652,
     "user": {
      "displayName": "Lucas",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgO-xqdSSwbB8xXos7Shqhpq7QJ06mYVUvdLDRcbQ=s64",
      "userId": "01670254553878112810"
     },
     "user_tz": 180
    },
    "id": "eZg-rYBzc9GQ",
    "outputId": "9f8c8fd5-5635-45d8-88f4-d4f1e5416dea"
   },
   "outputs": [],
   "source": [
    "FEATURES = ['height', 'sex_encoded']\n",
    "\n",
    "model = LinearRegression().fit(x[FEATURES], x.shoe_size)\n",
    "predicted = model.predict(x[FEATURES])\n",
    "\n",
    "evaluate(x.shoe_size, predicted)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "kzQtZr8nmR_K"
   },
   "source": [
    "Então não só reduzimos o erro absoluto médio de $1.07$ para $0.85$ (melhora de $21\\%$), como também estamos produzindo ainda menos erros grandes (nenhuma amostra teve um erro maior que $3$).\n",
    "\n",
    "Como ficaram os coeficientes?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 671,
     "status": "ok",
     "timestamp": 1598020475564,
     "user": {
      "displayName": "Lucas",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgO-xqdSSwbB8xXos7Shqhpq7QJ06mYVUvdLDRcbQ=s64",
      "userId": "01670254553878112810"
     },
     "user_tz": 180
    },
    "id": "t6LImuvbnLkK",
    "outputId": "26db1250-6455-4830-9aec-c3c5dab79763"
   },
   "outputs": [],
   "source": [
    "model.coef_.round(3), model.intercept_.round(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 285
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 1276,
     "status": "ok",
     "timestamp": 1598020477601,
     "user": {
      "displayName": "Lucas",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgO-xqdSSwbB8xXos7Shqhpq7QJ06mYVUvdLDRcbQ=s64",
      "userId": "01670254553878112810"
     },
     "user_tz": 180
    },
    "id": "uRROqBtlnLkU",
    "outputId": "a488154c-8ec5-40d1-8e7e-f2d45c3eace2"
   },
   "outputs": [],
   "source": [
    "sns.scatterplot(data=x, x='height', y='shoe_size',\n",
    "                hue='sex',\n",
    "                label='real data')\n",
    "\n",
    "a, b = model.coef_.round(1)\n",
    "c = model.intercept_.round(1)\n",
    "\n",
    "h = 150 + np.arange(80).reshape(-1, 1)\n",
    "\n",
    "s = np.ones(80).reshape(-1, 1)\n",
    "p_w = model.predict(np.hstack((h, s)))\n",
    "sns.lineplot(h.flatten(), p_w, label=f'f={a}h +{b}*1 +{c} (wo)')\n",
    "\n",
    "s = np.zeros(80).reshape(-1, 1)\n",
    "p_m = model.predict(np.hstack((h, s)))\n",
    "sns.lineplot(h.flatten(), p_m, label=f'f={a}h +{b}*0 +{c} (men)');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 674,
     "status": "ok",
     "timestamp": 1598020638123,
     "user": {
      "displayName": "Lucas",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgO-xqdSSwbB8xXos7Shqhpq7QJ06mYVUvdLDRcbQ=s64",
      "userId": "01670254553878112810"
     },
     "user_tz": 180
    },
    "id": "9M_9koKrcTPr",
    "outputId": "2ea6869a-71f8-47ea-e81a-3350ef3ae7ff"
   },
   "outputs": [],
   "source": [
    "model.predict([[155, 1],\n",
    "               [166, 0]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "C_clTy2Hme1x"
   },
   "source": [
    "Pela nossa análise no começo, os homens possuiam naturalmente tamanhos de sapato maiores que mulheres. Com o efeito fixo em ação, conseguimos construir \"duas\" linhas, onde cada linha otimiza o *mse* de seu próprio grupo.\n",
    "\n",
    "Efeitos fixos não resolvem todos os problemas. Não vai dar certo quando os diferentes grupos tem âng. de crescimento diferentes, já que esse modelo sempre gera retas paralelas. Nós podemos resolver esses casos com não-lineridade."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "FmgITGozqNju"
   },
   "source": [
    "#### Codificando características categóricas não-binárias\n",
    "\n",
    "Caso mais classes estivessem disponíveis (`woman`, `man`, `unknown`, `do_not_wish_to_disclosure`), elas seriam codificadas nos números inteiros `1`, `2`, `3` e `4`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 184148,
     "status": "ok",
     "timestamp": 1598020445891,
     "user": {
      "displayName": "Lucas",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgO-xqdSSwbB8xXos7Shqhpq7QJ06mYVUvdLDRcbQ=s64",
      "userId": "01670254553878112810"
     },
     "user_tz": 180
    },
    "id": "L-K46p1GB1nh",
    "outputId": "ab9fbf50-4717-4edd-b671-1addefd11c18"
   },
   "outputs": [],
   "source": [
    "LabelEncoder().fit_transform(['woman', 'man', 'unknown'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "3CL513Hq-yjR"
   },
   "source": [
    "Isso pode provocar um efeito indesejado, já que as classes agora não possuem efeitos fixos distintos, mas compartilharão um único coeficiente que é escalado pelo inteiro codificado.\n",
    "\n",
    "A forma mais comum de codificar variáveis não binárias é através do one-hot encoding. Neste formato, uma característica categorica com $C$ valores distintos é convertida em $C$ características binárias:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 104
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 184144,
     "status": "ok",
     "timestamp": 1598020445893,
     "user": {
      "displayName": "Lucas",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgO-xqdSSwbB8xXos7Shqhpq7QJ06mYVUvdLDRcbQ=s64",
      "userId": "01670254553878112810"
     },
     "user_tz": 180
    },
    "id": "WFSOW0hqdneQ",
    "outputId": "7e8285e8-54f0-4b4a-d4c2-79a26a1ff847"
   },
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import OneHotEncoder\n",
    "\n",
    "(OneHotEncoder()\n",
    " .fit_transform([['woman'],\n",
    "                 ['man'],\n",
    "                 ['man'],\n",
    "                 ['do_not_wish_to_disclosure'],\n",
    "                 ['woman']])\n",
    " .todense()\n",
    " .tolist())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Ahy-Ctb7evdq"
   },
   "source": [
    "A nova *feature* $c_i$ assume o valor $1$ quando a amostra pertence à categoria $i$ e $0$ caso contrário. O modelo agora terá liberdade para aprender três parâmetros diferentes e aplica-los sobre a predição dependendo da categoria a qual a amostra pertence."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Lw5Eg6LfCzwG"
   },
   "source": [
    "### Regressões lineares utilizando o Tensorflow\n",
    "\n",
    "A regressão linear pode ser vista como um caso específico de rede neural, composta de uma única camada interna e ativação linear.\n",
    "Atualmente o framework mais comum utilizado na implementação de redes é o Tensorflow. Ele permite a criação de regressões da seguinte maneira:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "SvLsmsvlC2qc"
   },
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "\n",
    "from tensorflow.keras import Sequential\n",
    "from tensorflow.keras.layers import InputLayer, Dense\n",
    "\n",
    "model = Sequential([\n",
    "    InputLayer([2]),\n",
    "    Dense(1, activation='linear', name='predictions')\n",
    "])\n",
    "\n",
    "model.compile(\n",
    "    optimizer=tf.optimizers.SGD(learning_rate=.01),\n",
    "    loss='mse',\n",
    "    metrics=['mse', 'mae'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 191
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 184653,
     "status": "ok",
     "timestamp": 1598020446410,
     "user": {
      "displayName": "Lucas",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgO-xqdSSwbB8xXos7Shqhpq7QJ06mYVUvdLDRcbQ=s64",
      "userId": "01670254553878112810"
     },
     "user_tz": 180
    },
    "id": "LRTajgIuD4Ag",
    "outputId": "400d76d0-523c-4b0d-c1d5-70ada9590fdb"
   },
   "outputs": [],
   "source": [
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 201
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 184650,
     "status": "ok",
     "timestamp": 1598020446412,
     "user": {
      "displayName": "Lucas",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgO-xqdSSwbB8xXos7Shqhpq7QJ06mYVUvdLDRcbQ=s64",
      "userId": "01670254553878112810"
     },
     "user_tz": 180
    },
    "id": "1gsy8O6FvT9s",
    "outputId": "a36d1be2-0cf1-480b-e939-46d6954c7434"
   },
   "outputs": [],
   "source": [
    "tf.keras.utils.plot_model(model, show_shapes=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 185
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 185388,
     "status": "error",
     "timestamp": 1598020447157,
     "user": {
      "displayName": "Lucas",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgO-xqdSSwbB8xXos7Shqhpq7QJ06mYVUvdLDRcbQ=s64",
      "userId": "01670254553878112810"
     },
     "user_tz": 180
    },
    "id": "t0UPe1CUEkXi",
    "outputId": "140f4630-1c52-444c-d70d-c3463cfce939"
   },
   "outputs": [],
   "source": [
    "model.fit(x[FEATURES], x.shoe_size,\n",
    "          epochs=4);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "i8BxjCwPFLEt"
   },
   "source": [
    "Vixe. Infinito definitivamente não parece bom.\n",
    "\n",
    "Redes são modelos paramétricos. Os pesos $w$ são iniciados com valores amostrados de uma distribuição normal, enquanto *b* com $0$.\n",
    "\n",
    "Ao receber características (ou predizer resultados) muito distantes da normal $(0, 1)$, o modelo precisa percorrer um grande caminho até que seu sinal de saída finalmente escale e translade para a distribuição de saída emparelhado.\n",
    "\n",
    "O scikit possui a classe [StandardScaler](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.StandardScaler.html), que \"aprende\" a média e desvio-padrão de um conjunto e consegue \"normaliza-lo\" removendo a média de cada característica e dividindo pelo desvio padrão."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "BIl6gv4vG4En"
   },
   "outputs": [],
   "source": [
    "model = Sequential([\n",
    "    InputLayer([2]),\n",
    "    Dense(1, activation='linear', name='predictions')\n",
    "])\n",
    "\n",
    "model.compile(\n",
    "    optimizer=tf.optimizers.SGD(learning_rate=.005),\n",
    "    loss='mse',\n",
    "    metrics=['mse', 'mae'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ltCopsGsG-wK"
   },
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "x_scaler, y_scaler = StandardScaler(), StandardScaler()\n",
    "\n",
    "z = x_scaler.fit_transform(x[features])\n",
    "y = y_scaler.fit_transform(x.shoe_size.values.reshape(-1, 1))\n",
    "\n",
    "model.fit(\n",
    "    z, y,\n",
    "    epochs=300,\n",
    "    batch_size=32,\n",
    "    verbose=0,\n",
    "    callbacks=[\n",
    "        tf.keras.callbacks.EarlyStopping('mae',\n",
    "                                         patience=10,\n",
    "                                         restore_best_weights=True)\n",
    "    ]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "N2WWUk5aIuSq"
   },
   "outputs": [],
   "source": [
    "h = pd.DataFrame(model.history.history)\n",
    "h['epoch'] = h.index\n",
    "\n",
    "sns.lineplot(\n",
    "    x='epoch',\n",
    "    y='value',\n",
    "    hue='variable',\n",
    "    data=h.melt(['epoch'], ['mse', 'mae']));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "p-_jDhSrLBdS"
   },
   "outputs": [],
   "source": [
    "predicted = model.predict(z)\n",
    "predicted = y_scaler.inverse_transform(predicted).flatten()\n",
    "\n",
    "evaluate(x.shoe_size, predicted)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "abzZRtzvIBWH"
   },
   "source": [
    "### Próximos passos: *features* não lineares, redes não-lineares\n",
    "\n",
    "Não temos mais features para adicionar.\n",
    "Ainda é possível melhorar esse modelo?\n",
    "\n",
    "Até agora, estamos considerando a relação linear entre as variáveis e o tamanho do sapato. O que aconteceria se esse relacionamento fosse não-linear?\n",
    "Uma forma de modelar isso é utilizando o transformador [PolynomialFeatures](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.PolynomialFeatures.html), onde as características são utilizadas para a construção dos multiplos termos de um polinômio de grau `degree`.\n",
    "Cada termo constitui uma nova característica alimentada ao modelo linear.\n",
    "Temos então um modelo polinomial (em relação ao dado de entrada) com treinamento\n",
    "linear."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "FNN0S1pRJZ46"
   },
   "outputs": [],
   "source": [
    "from sklearn.pipeline import make_pipeline\n",
    "from sklearn.preprocessing import PolynomialFeatures\n",
    "\n",
    "model = make_pipeline(\n",
    "    StandardScaler(),\n",
    "    PolynomialFeatures(degree=2),\n",
    "    LinearRegression()\n",
    ")\n",
    "\n",
    "model.fit(x[features], x.shoe_size)\n",
    "predicted = model.predict(x[features])\n",
    "evaluate(x.shoe_size, predicted)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "-1BLDIr-KdZi"
   },
   "outputs": [],
   "source": [
    "names = [n.replace('x0', features[0]).replace('x1', features[1])\n",
    "         for n in model.named_steps['polynomialfeatures'].get_feature_names()]\n",
    "importance = np.abs(model.named_steps['linearregression'].coef_)\n",
    "importance /= importance.sum()\n",
    "\n",
    "plt.figure(figsize=(5, 2))\n",
    "sns.barplot(names, importance)\n",
    "plt.xticks(rotation=90);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "K5sMKrzmwq7E"
   },
   "source": [
    "Uma outra forma é não limitar em features polinomiais, mas colocar mais camadas não-lineares na rede, diretamente. Isso dá mais liberdade para o sistema, mas a função de perda (em relação à alguns pesos $\\theta$) não é mais uma função linear, o que implica que a equação $\\frac{\\partial E}{\\partial \\theta} = 0$ possui múltiplas soluções e nossa busca local nem sempre produz o melhor resultado.\n",
    "\n",
    "Nós podemos entrar em mais detalhes quando falarmos sobre modelos não-lineares, mas só um exemplo de utilização por enquanto:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "6qZCGySuv4zy"
   },
   "outputs": [],
   "source": [
    "from tensorflow.keras.layers import BatchNormalization\n",
    "\n",
    "model = Sequential([\n",
    "    InputLayer([2]),\n",
    "    Dense(1024, activation='relu', name='fc1'),\n",
    "    Dense(1024, activation='relu', name='fc2'),\n",
    "    Dense(1, activation='linear', name='predictions')\n",
    "])\n",
    "\n",
    "model.compile(\n",
    "    optimizer='sgd',  # or tf.optimizers.SGD(learning_rate=.01),\n",
    "    loss='mse',\n",
    "    metrics=['mse', 'mae'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "J6viC1ltv89S"
   },
   "outputs": [],
   "source": [
    "tf.keras.utils.plot_model(model, show_shapes=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "AzO6mUhAwDEd"
   },
   "outputs": [],
   "source": [
    "model.fit(\n",
    "    z, y,\n",
    "    epochs=300,\n",
    "    batch_size=32,\n",
    "    verbose=0,\n",
    "    callbacks=[\n",
    "        tf.keras.callbacks.EarlyStopping('mae',\n",
    "                                         patience=10,\n",
    "                                         restore_best_weights=True)\n",
    "    ]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "gjX2lsGcweqt"
   },
   "outputs": [],
   "source": [
    "h = pd.DataFrame(model.history.history)\n",
    "h['epoch'] = h.index\n",
    "\n",
    "sns.lineplot(\n",
    "    x='epoch',\n",
    "    y='value',\n",
    "    hue='variable',\n",
    "    data=h.melt(['epoch'], ['mse', 'mae']));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "aaR-_R1mwE19"
   },
   "outputs": [],
   "source": [
    "predicted = model.predict(z)\n",
    "predicted = y_scaler.inverse_transform(predicted).flatten()\n",
    "\n",
    "evaluate(x.shoe_size, predicted)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "-wF6H4JQPdbu"
   },
   "outputs": [],
   "source": [
    "sns.scatterplot(data=x, x='height', y='shoe_size',\n",
    "                hue='sex',\n",
    "                label='real data')\n",
    "\n",
    "h = 150 + np.arange(80).reshape(-1, 1)\n",
    "s = np.ones(80).reshape(-1, 1)\n",
    "s = np.hstack((h, s))\n",
    "s = x_scaler.transform(s)\n",
    "s = model.predict(s)\n",
    "s = y_scaler.inverse_transform(s)\n",
    "sns.lineplot(h.flatten(), s.flatten(), label=f'nn wo')\n",
    "\n",
    "s = np.zeros(80).reshape(-1, 1)\n",
    "s = np.hstack((h, s))\n",
    "s = x_scaler.transform(s)\n",
    "s = model.predict(s)\n",
    "s = y_scaler.inverse_transform(s)\n",
    "sns.lineplot(h.flatten(), s.flatten(), label=f'nn men');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "8s3-IJ6aPHvb"
   },
   "source": [
    "Redes neurais não-lineares com muitas unidades são extremamente flexíveis em seu comportamento, mas são extremamente sensíveis à ruído e irão super-especificar com facilidade. O exemplo acima é só ilustrativo e não deve ser usado pra esse problema."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "B5tTEPNHfQ8D"
   },
   "source": [
    "### Generalização e teste\n",
    "\n",
    "Todas as análises acima foram construídas e avaliadas sobre um único conjunto de dados. Nós modelamos o treinamento como um processo de otimização local e fechado, considerando toda a informação que tinhamos acesso até o momento.\n",
    "Entretando, não é razoável assumir que essas mesmas amostras irão re-indicir durante o estágio de inferência do modelo treinado, já que existem muitos outros compradores utilizando o nosso sistema.\n",
    "\n",
    "Nós temos uma buraco aqui: nós queremos o modelo que otimiza MAE durante o estágio de inferência, não o que otimiza MAE em treino; mas nós selecionamos os parâmetros de acordo com a segunda métrica. Isso introduz o grande problema de machine learning: *overffiting*."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}