classificação_digitos_MNIST.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.6.5"
    },
    "nav_menu": {},
    "toc": {
      "navigate_menu": true,
      "number_sections": true,
      "sideBar": true,
      "threshold": 6,
      "toc_cell": false,
      "toc_section_display": "block",
      "toc_window_display": false
    },
    "colab": {
      "name": "classificação_digitos_MNIST.ipynb",
      "provenance": [],
      "include_colab_link": true
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Mgrinet/classificacao-digitos-MNIST/blob/master/classifica%C3%A7%C3%A3o_digitos_MNIST.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0EWDHqsNR3WQ",
        "colab_type": "text"
      },
      "source": [
        "# Classificação de Digitos - MNIST\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wGJLzxTbR3WS",
        "colab_type": "text"
      },
      "source": [
        "## Configuração"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Fgy704tkR3WT",
        "colab_type": "text"
      },
      "source": [
        "Primeiro, vamos garantir que este notebook funcione bem tanto no python 2 quanto no 3, importe alguns módulos comuns, garanta que o MatplotLib plote figuras em linha e prepare uma função para salvar os números:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9gG6lbleR3WU",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Para funcionar tanto no python 2 quanto no python 3\n",
        "from __future__ import division, print_function, unicode_literals\n",
        "\n",
        "# Importar bibliotecas\n",
        "import numpy as np\n",
        "import os\n",
        "\n",
        "# Estabilizar aleatoriedade do notebook\n",
        "np.random.seed(42)\n",
        "\n",
        "# plotar os graficos\n",
        "%matplotlib inline\n",
        "import matplotlib as mpl\n",
        "import matplotlib.pyplot as plt\n",
        "mpl.rc('axes', labelsize=14)\n",
        "mpl.rc('xtick', labelsize=12)\n",
        "mpl.rc('ytick', labelsize=12)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PGT6hhihR3WX",
        "colab_type": "text"
      },
      "source": [
        "## MNIST"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0FUNJe8wR3WX",
        "colab_type": "text"
      },
      "source": [
        "Neste capítulo, usaremos o conjunto de dados MNIST, que é um conjunto de 70.000\n",
        "imagens de dígitos manuscritas por alunos do ensino médio e funcionários do Censo dos EUA. Cada imagem é rotulada com o dígito que representa\n",
        "\n",
        "O Scikit-Learn fornece muitas funções auxiliares para baixar datasets populares, e o MNIST é um deles. O código a seguir busca o conjunto de dados MNIST:\n",
        "\n",
        "**Atenção**: `fetch_mldata()` está obsoleto desde o Scikit-Learn 0.20. Você deve usar `fetch_openml()`. No entanto, ele retorna o conjunto de dados MNIST não classificado, enquanto `fetch_mldata()` retornou o conjunto de dados classificado por destino (o conjunto de treinamento e o teste de teste foram classificados separadamente). Em geral, isso é bom, mas se você quiser obter exatamente os mesmos resultados de antes, precisará classificar o conjunto de dados usando a seguinte função:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HgOlqn08R3WY",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def sort_by_target(mnist):\n",
        "    reorder_train = np.array(sorted([(target, i) for i, target in enumerate(mnist.target[:60000])]))[:, 1]\n",
        "    reorder_test = np.array(sorted([(target, i) for i, target in enumerate(mnist.target[60000:])]))[:, 1]\n",
        "    mnist.data[:60000] = mnist.data[reorder_train]\n",
        "    mnist.target[:60000] = mnist.target[reorder_train]\n",
        "    mnist.data[60000:] = mnist.data[reorder_test + 60000]\n",
        "    mnist.target[60000:] = mnist.target[reorder_test + 60000]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uVFrYNnDR3Wa",
        "colab_type": "code",
        "colab": {},
        "outputId": "7c26c353-4201-4d90-e22e-9694a44455c4"
      },
      "source": [
        "try:\n",
        "    from sklearn.datasets import fetch_openml\n",
        "    mnist = fetch_openml('mnist_784', version=1, cache=True)\n",
        "    mnist.target = mnist.target.astype(np.int8) # fetch_openml() returns targets as strings\n",
        "    sort_by_target(mnist) # fetch_openml() returns an unsorted dataset\n",
        "except ImportError:\n",
        "    from sklearn.datasets import fetch_mldata\n",
        "    mnist = fetch_mldata('MNIST original')\n",
        "mnist[\"data\"], mnist[\"target\"], mnist[\"DESCR\"]"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(array([[0, 0, 0, ..., 0, 0, 0],\n",
              "        [0, 0, 0, ..., 0, 0, 0],\n",
              "        [0, 0, 0, ..., 0, 0, 0],\n",
              "        ...,\n",
              "        [0, 0, 0, ..., 0, 0, 0],\n",
              "        [0, 0, 0, ..., 0, 0, 0],\n",
              "        [0, 0, 0, ..., 0, 0, 0]], dtype=uint8),\n",
              " array([0., 0., 0., ..., 9., 9., 9.]),\n",
              " 'mldata.org dataset: mnist-original')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ql0SyQOAR3Wd",
        "colab_type": "text"
      },
      "source": [
        "Os datasets carregados pelo Scikit-Learn geralmente têm uma estrutura de dicionário semelhante, incluindo:\n",
        "\n",
        "• Uma chave \"DESCR\" descrevendo o conjunto de dados\n",
        "\n",
        "• Uma chave \"data\" contendo uma matriz com uma linha por instância e uma coluna por característica\n",
        "\n",
        "• Uma chave \"target\" contendo uma matriz com os rótulos"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "U1IWQ0oLR3We",
        "colab_type": "code",
        "colab": {},
        "outputId": "abebd929-313a-4828-9938-40ba2bb192c5"
      },
      "source": [
        "mnist.data.shape"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(70000, 784)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AmBg6IFYR3Wg",
        "colab_type": "code",
        "colab": {},
        "outputId": "4a2eb373-ad75-4fcd-c207-74dd298c0391"
      },
      "source": [
        "X, y = mnist[\"data\"], mnist[\"target\"]\n",
        "X.shape"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(70000, 784)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9Zsc8uCAR3Wi",
        "colab_type": "code",
        "colab": {},
        "outputId": "f0be1453-6649-4f5b-8981-df623ad59b80"
      },
      "source": [
        "y.shape"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(70000,)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8k8ZvwpNR3Wk",
        "colab_type": "text"
      },
      "source": [
        "Existem 70.000 imagens e cada imagem possui 784 features. Isso ocorre porque cada imagem é 28 × 28 pixels, e cada recurso representa apenas a intensidade de um pixel, de 0 (branco) a 255 (preto). Vamos dar uma olhada em um dígito do conjunto de dados. Tudo o que você precisa fazer é pegar o vetor de features de uma instância, reformulá-lo para uma matriz 28 × 28 e exibi-lo usando Função `imshow()` do Matplotlib:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UAdCx_0nR3Wl",
        "colab_type": "code",
        "colab": {},
        "outputId": "9cb566f3-8605-4077-e39d-83d4053236f8"
      },
      "source": [
        "28*28"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "784"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bTbgrqmPR3Wn",
        "colab_type": "code",
        "colab": {},
        "outputId": "0a1e12b8-ec5f-4382-95ac-422de25f7322"
      },
      "source": [
        "some_digit = X[36000]\n",
        "some_digit_image = some_digit.reshape(28, 28)\n",
        "plt.imshow(some_digit_image, cmap = mpl.cm.binary,\n",
        "           interpolation=\"nearest\")\n",
        "plt.axis(\"off\")\n",
        "plt.show()\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Saving figure some_digit_plot\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BXCIdxf9R3Wq",
        "colab_type": "text"
      },
      "source": [
        "Isso parece um 5 e, de fato, é isso que o label nos confirma:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YcGPJWvPR3Wq",
        "colab_type": "code",
        "colab": {},
        "outputId": "1828ebad-d684-45de-dda4-454f79640f41"
      },
      "source": [
        "y[36000]"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5.0"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JDvAW_FwR3Ws",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def plot_digit(data):\n",
        "    image = data.reshape(28, 28)\n",
        "    plt.imshow(image, cmap = mpl.cm.binary,\n",
        "               interpolation=\"nearest\")\n",
        "    plt.axis(\"off\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AlCiTEFrR3Wu",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# EXTRA\n",
        "def plot_digits(instances, images_per_row=10, **options):\n",
        "    size = 28\n",
        "    images_per_row = min(len(instances), images_per_row)\n",
        "    images = [instance.reshape(size,size) for instance in instances]\n",
        "    n_rows = (len(instances) - 1) // images_per_row + 1\n",
        "    row_images = []\n",
        "    n_empty = n_rows * images_per_row - len(instances)\n",
        "    images.append(np.zeros((size, size * n_empty)))\n",
        "    for row in range(n_rows):\n",
        "        rimages = images[row * images_per_row : (row + 1) * images_per_row]\n",
        "        row_images.append(np.concatenate(rimages, axis=1))\n",
        "    image = np.concatenate(row_images, axis=0)\n",
        "    plt.imshow(image, cmap = mpl.cm.binary, **options)\n",
        "    plt.axis(\"off\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aYVs9qVHR3Ww",
        "colab_type": "text"
      },
      "source": [
        "Esta figura mostra mais algumas imagens do conjunto de dados MNIST para dar uma ideia da complexidade da tarefa de classificação."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MMB8SKuaR3Wx",
        "colab_type": "code",
        "colab": {},
        "outputId": "ed915260-e904-48fe-aa65-fe934ea939c9"
      },
      "source": [
        "plt.figure(figsize=(9,9))\n",
        "example_images = np.r_[X[:12000:600], X[13000:30600:600], X[30600:60000:590]]\n",
        "plot_digits(example_images, images_per_row=10)\n",
        "save_fig(\"more_digits_plot\")\n",
        "plt.show()"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Saving figure more_digits_plot\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 648x648 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pTBnIEtYR3Wz",
        "colab_type": "text"
      },
      "source": [
        "**Lembrando**: Você deve sempre criar um conjunto de testes e colocá-lo de lado antes de inspecionar os dados\n",
        "de perto. O conjunto de dados MNIST na verdade já está dividido em um conjunto de treinamento (os primeiros 60.000\n",
        "imagens) e um conjunto de teste (as últimas 10.000 imagens):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RmBQbQILR3W0",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "X_train, X_test, y_train, y_test = X[:60000], X[60000:], y[:60000], y[60000:]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NDlXuQ-PR3W1",
        "colab_type": "text"
      },
      "source": [
        "Vamos também embaralhar (shuffle) o conjunto de treinamento; isso garantirá que todas as dobras (folds) de validação cruzada seja semelhante (você não quer que uma dobra fique faltando alguns dígitos). Além disso, alguns algoritmos de aprendizado são sensíveis à ordem das instâncias de treinamento, e eles executam\n",
        "mal se eles obterem muitos casos semelhantes seguidos. Embaralhar o conjunto de dados garante que isso não aconteça:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "v2jdnYLUR3W2",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import numpy as np\n",
        "\n",
        "shuffle_index = np.random.permutation(60000)\n",
        "X_train, y_train = X_train[shuffle_index], y_train[shuffle_index]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5PKTYpKkR3W4",
        "colab_type": "text"
      },
      "source": [
        "**Atenção!** O embaralhamento pode ser uma má ideia em alguns contextos - por exemplo, se você estiver trabalhando em dados de séries temporais (como preços do mercado de ações ou condições climáticas). Vamos explorar isso nas próximas aulas."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "u4ffn5xeR3W5",
        "colab_type": "text"
      },
      "source": [
        "## Classificador Binario\n",
        "\n",
        "Vamos simplificar o problema por enquanto e tentar identificar apenas um dígito - por exemplo, o número 5. Esse \"detector de número 5\" será um exemplo de um classificador binário, capaz de distinguir entre apenas duas classes, 5 e não-5. Vamos criar os vetores de destino para esta tarefa de classificação:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2BUrQZyfR3W5",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "y_train_5 = (y_train == 5) #Verdadeiro para todos os 5s, Falso para todos os outros dígitos.\n",
        "y_test_5 = (y_test == 5)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_yVF6h3aR3W7",
        "colab_type": "text"
      },
      "source": [
        "Ok, agora vamos escolher um classificador e treiná-lo. Um bom lugar para começar é com um classificador de gradiente descendente estocástico (SGD), usando a classe SGDClassifier do Scikit-Learn. Esse classificador tem a vantagem de ser capaz de lidar com conjuntos de dados muito grandes de maneira eficiente. Isto é em parte porque o SGD lida com instâncias de treinamento independentemente, uma de cada vez (o que também torna o SGD adequado para o aprendizado online), como veremos mais adiante. Vamos criar um SGDClassifier e treiná-lo em todo o conjunto de treinamento:\n",
        "\n",
        "**Nota**: Alguns hiperparâmetros terão um valor padrão diferente em versões futuras do Scikit-Learn, portanto, um aviso será emitido se você não os definir explicitamente. É por isso que definimos `max_iter=5` e` tol=-np.infty`, para obter os mesmos resultados que no livro, evitando os avisos."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Zmf2BKCqR3W8",
        "colab_type": "code",
        "colab": {},
        "outputId": "b1ea2411-2a69-406b-fa7b-e5bed315c790"
      },
      "source": [
        "from sklearn.linear_model import SGDClassifier\n",
        "\n",
        "sgd_clf = SGDClassifier(max_iter=5, tol=-np.infty, random_state=42)\n",
        "sgd_clf.fit(X_train, y_train_5)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "SGDClassifier(alpha=0.0001, average=False, class_weight=None, epsilon=0.1,\n",
              "       eta0=0.0, fit_intercept=True, l1_ratio=0.15,\n",
              "       learning_rate='optimal', loss='hinge', max_iter=5, n_iter=None,\n",
              "       n_jobs=1, penalty='l2', power_t=0.5, random_state=42, shuffle=True,\n",
              "       tol=-inf, verbose=0, warm_start=False)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UZzLJJmfR3W-",
        "colab_type": "text"
      },
      "source": [
        "Agora vamos usá-lo para detectar imagens do número 5:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oGtp_0ptR3XE",
        "colab_type": "code",
        "colab": {},
        "outputId": "509f827a-0b8b-4a77-d006-e9c9840654bb"
      },
      "source": [
        "sgd_clf.predict([some_digit])"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ True])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "odOQOs0wR3XH",
        "colab_type": "text"
      },
      "source": [
        "O classificador adivinha que essa imagem representa um 5 (True). Agora, vamos avaliar o desempenho desse modelo."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-ezlKcnvR3XI",
        "colab_type": "text"
      },
      "source": [
        "## Medidas de Desempenho\n",
        "\n",
        "Avaliar um classificador é bem mais complicado do que avaliar um regressor, então vamos dar uma olhada nas varias medidas de desempenho disponíveis!\n",
        "\n",
        "\n",
        "**Medindo Precisão Usando Validação Cruzada (Cross-Validation)**\n",
        "\n",
        "Uma boa maneira de avaliar um modelo é usar validação cruzada"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ENBm12hiR3XI",
        "colab_type": "code",
        "colab": {},
        "outputId": "3ee72ceb-5f17-49b5-90b3-3aa27c35445c"
      },
      "source": [
        "from sklearn.model_selection import cross_val_score\n",
        "cross_val_score(sgd_clf, X_train, y_train_5, cv=3, scoring=\"accuracy\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0.9502 , 0.96565, 0.96495])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JBljhkMtR3XK",
        "colab_type": "text"
      },
      "source": [
        "As vezes, você precisa de mais controle sobre o processo de validação cruzada do que o que `cross_val_score()` e funções similares fornecem. Nesses casos, você pode implementar a validação cruzada por conta própria; Na verdade, é bastante simples. O código a seguir faz basicamente o mesmo que o código `cross_val_score()` anterior e imprime o mesmo resultado:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7aLmk1SeR3XL",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from sklearn.model_selection import StratifiedKFold\n",
        "from sklearn.base import clone\n",
        "\n",
        "skfolds = StratifiedKFold(n_splits=3, random_state=42)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8yuuYbNCR3XN",
        "colab_type": "text"
      },
      "source": [
        "A classe StratifiedKFold realiza amostragem estratificada para produzir dobras (folds) que contêm uma proporção representativa de cada classe. Em cada iteração, o código cria um clone do classificador, treina os clones nas dobras de treinamento e faz previsões na dobra de teste. Em seguida, conta o número de previsões corretas e gera a proporção de previsões corretas."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2TChjOK-R3XN",
        "colab_type": "code",
        "colab": {},
        "outputId": "c1c5fe4c-49ca-4589-9e9f-063eda72fc4a"
      },
      "source": [
        "for train_index, test_index in skfolds.split(X_train, y_train_5):\n",
        "    clone_clf = clone(sgd_clf)\n",
        "    X_train_folds = X_train[train_index]\n",
        "    y_train_folds = (y_train_5[train_index])\n",
        "    X_test_fold = X_train[test_index]\n",
        "    y_test_fold = (y_train_5[test_index])\n",
        "\n",
        "    clone_clf.fit(X_train_folds, y_train_folds)\n",
        "    y_pred = clone_clf.predict(X_test_fold)\n",
        "    n_correct = sum(y_pred == y_test_fold)\n",
        "    print(n_correct / len(y_pred))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0.9502\n",
            "0.96565\n",
            "0.96495\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nJ-aUqzdR3XQ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from sklearn.base import BaseEstimator\n",
        "class Never5Classifier(BaseEstimator):\n",
        "    def fit(self, X, y=None):\n",
        "        pass\n",
        "    def predict(self, X):\n",
        "        return np.zeros((len(X), 1), dtype=bool)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JRYVEs9dR3XR",
        "colab_type": "text"
      },
      "source": [
        "Vamos usar a função `cross_val_score()` para avaliar o modelo SGDClassifier usando validação cruzada de K-fold com três dobras. Lembrando que a validação cruzada K-fold significa dividir o conjunto de treinamento em K dobras (neste caso, três), depois fazer previsões e avaliá-las em cada dobra, usando um modelo treinado nas dobras restantes:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZpabLMaCR3XS",
        "colab_type": "code",
        "colab": {},
        "outputId": "61ce3b20-7239-4145-a05e-9964d8d0cfd1"
      },
      "source": [
        "never_5_clf = Never5Classifier()\n",
        "cross_val_score(never_5_clf, X_train, y_train_5, cv=3, scoring=\"accuracy\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0.909  , 0.90715, 0.9128 ])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9vpeIwZAR3XU",
        "colab_type": "text"
      },
      "source": [
        "Acima de 95% de acurácia (razão de previsões corretas) em todas as dobras de validação cruzada. Isso parece muito bom, mas antes de ficar muito animado, vamos ver porque um classificador que aparenta ser muito bom pode, na verdade, não ser tão bom assim...\n",
        "\n",
        "Isto é simplesmente porque apenas 10% das imagens são 5s, então se você sempre acha que uma imagem não é 5, você estará certo em 90% do tempo.\n",
        "\n",
        "**Resumindo**: Uma classificação binária em uma configuração desproporcional pode causar resultados enganosos.\n",
        "\n",
        "Isso demonstra por que a precisão geralmente não é a medida de desempenho preferencial para os classificadores, especialmente quando você está lidando com datasets distorcidos (skewed) (ou seja, quando algumas classes são muito mais frequentes do que outras)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jtl-uyfWR3XU",
        "colab_type": "text"
      },
      "source": [
        "## Matriz de Confusão\n",
        "\n",
        "Uma maneira muito melhor de avaliar o desempenho de um classificador é observar a matriz de confusão. A ideia geral é contar o número de vezes que as instâncias da classe A são classificadas como classe B. Por exemplo, para saber o número de vezes que o classificador confundiu imagens de 5s com 3s, você procuraria na quinta linha e na terceira coluna do matriz de confusão.\n",
        "Para calcular a matriz de confusão, primeiro você precisa ter um conjunto de previsões, para que elas possam ser comparadas com os alvos reais. Você pode fazer previsões no conjunto de testes, mas vamos mantê-lo intocado por enquanto (lembrando que sempre queremos usar o conjunto de testes apenas no final do projeto, depois de ter um classificador pronto para ser iniciado).\n",
        "\n",
        "Em vez disso, você pode usar a função `cross_val_predict()`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6iObxsCYR3XV",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from sklearn.model_selection import cross_val_predict\n",
        "\n",
        "y_train_pred = cross_val_predict(sgd_clf, X_train, y_train_5, cv=3)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1HYqXwTQR3XW",
        "colab_type": "text"
      },
      "source": [
        "Assim como a função `cross_val_score()`, `cross_val_predict()` executa a validação cruzada de K-fold, mas, em vez de retornar as pontuações de avaliação, retorna as previsões feitas em cada dobra de teste. Isso significa que você obtém uma previsão limpa para cada instância no conjunto de treinamento (“limpa”, significando que a previsão é feita por um modelo que nunca viu os dados durante o treinamento).\n",
        "\n",
        "Cada linha em uma matriz de confusão representa uma classe real, enquanto cada coluna representa uma classe prevista. \n",
        "\n",
        "A primeira linha desta matriz considera imagens \"não-5\" (a classe negativa): 53.272 delas foram corretamente classificadas como \"não-5\" (elas são chamadas de verdadeiros negativos), enquanto as 1.307 restantes foram erroneamente classificadas como 5s (falsos positivos). \n",
        "\n",
        "A segunda linha considera as imagens de 5s (a classe positiva): 1.077 foram erroneamente classificados como \"não-5s\" (falsos negativos), enquanto os restantes 4.344 foram classificados corretamente como 5s (positivos verdadeiros). "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fCE6i086R3XX",
        "colab_type": "code",
        "colab": {},
        "outputId": "6a994807-8608-4da9-9790-78bbeb6fb894"
      },
      "source": [
        "from sklearn.metrics import confusion_matrix\n",
        "\n",
        "confusion_matrix(y_train_5, y_train_pred)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[53272,  1307],\n",
              "       [ 1077,  4344]], dtype=int64)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6z4UbyM-R3XZ",
        "colab_type": "text"
      },
      "source": [
        "Um classificador perfeito teria apenas verdadeiros positivos e verdadeiros negativos, portanto, sua matriz de confusão teria valores diferentes de zero apenas em sua diagonal principal (parte superior esquerda para a parte inferior direita):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5U08YmqTR3Xa",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "y_train_perfect_predictions = y_train_5"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uAq13w5nR3Xb",
        "colab_type": "code",
        "colab": {},
        "outputId": "19aa36a5-f34b-4e49-ec96-60c79fa1d0dc"
      },
      "source": [
        "confusion_matrix(y_train_5, y_train_perfect_predictions)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[54579,     0],\n",
              "       [    0,  5421]], dtype=int64)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nUULQzNKR3Xd",
        "colab_type": "text"
      },
      "source": [
        "A matriz de confusão fornece muitas informações, mas às vezes você pode preferir uma métrica mais concisa. Uma métrica interessante é olhar para a precisão das previsões positivas; isso é chamado a precisão do classificador:\n",
        "\n",
        "\n",
        "## Precisão e Recall\n",
        "Precisão = TP/(TP+FP)\n",
        "\n",
        "Onde:\n",
        "TP é o número de positivos verdadeiros, e FP é o número de falsos positivos.\n",
        "\n",
        "Uma maneira facil de obter precisão perfeita é fazer uma única previsão positiva e garantir que esteja correta (precisão = 1/1 = 100%). Isso não seria muito útil, pois o classificador ignoraria todas, exceto uma instância positiva. Então precisão é tipicamente usada junto com outra métrica chamada recall, também chamada de sensibilidade ou taxa positiva verdadeira (TPR).\n",
        "\n",
        "(TPR): esta é a proporção de instâncias positivas que são corretamente detectadas pelo classificador\n",
        "\n",
        "Recall = TP/(TP+FN)\n",
        "\n",
        "Onde: FN é, obviamente, o número de falsos negativos.\n",
        "\n",
        "\n",
        "O Scikit-Learn fornece várias funções para calcular as métricas do classificador, incluindo precisão e recall:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sfrQb2HsR3Xe",
        "colab_type": "code",
        "colab": {},
        "outputId": "d9214a14-3001-456a-98b6-a3082a13849c"
      },
      "source": [
        "from sklearn.metrics import precision_score, recall_score\n",
        "\n",
        "print('precisão', precision_score(y_train_5, y_train_pred))\n",
        "\n",
        "print('recall:', recall_score(y_train_5, y_train_pred))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "precisão 0.7687135020350381\n",
            "recall: 0.801328168234643\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hKbwh2ubR3Xg",
        "colab_type": "text"
      },
      "source": [
        "Agora o seu \"detector de número 5\" não parece tão bom como quando você olhou para a sua precisão. Quando o modelo afirma que uma imagem representa um 5, ela está correta apenas ~77% do tempo. Além disso, detecta apenas ~80% dos 5s.\n",
        "\n",
        "Geralmente é conveniente combinar precisão e recall em uma única métrica chamada pontuação F1, em particular se você precisar de uma maneira simples de comparar dois classificadores. A pontuação F1 é a média harmônica de precisão e recordação.\n",
        "\n",
        "F1 = 2* (precisão*recall)/(precisão+recall) = TP/(TP+((FN+FP)/2))\n",
        "\n",
        "Enquanto a média regular trata todos os valores igualmente, a média harmônica atribui muito mais peso a valores baixos. Como resultado, o classificador só obterá uma pontuação alta na F1 se tanto a recordação quanto a precisão forem altas.\n",
        "\n",
        "**Resumindo**: A média harmônica penaliza mais os valores menores.\n",
        "\n",
        "Para calcular a pontuação F1, simplesmente chame a função `f1_score()`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kXkTZFemR3Xg",
        "colab_type": "code",
        "colab": {},
        "outputId": "f418a122-4a3c-406f-a8e2-55e6798b9261"
      },
      "source": [
        "from sklearn.metrics import f1_score\n",
        "f1_score(y_train_5, y_train_pred)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.7846820809248555"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cjZX8gd6R3Xi",
        "colab_type": "code",
        "colab": {},
        "outputId": "c928811f-d935-4f34-ba90-8dafc92ef0d8"
      },
      "source": [
        "4344 / (4344 + (1077 + 1307)/2)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.7846820809248555"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z5LbxcmtR3Xl",
        "colab_type": "text"
      },
      "source": [
        "A pontuação de F1 favorece os classificadores que têm precisão e recall semelhantes. \n",
        "\n",
        "Isso nem sempre é o que você quer: em alguns contextos você se preocupa principalmente com a precisão e em outros contextos que realmente se preocupam com o recall. \n",
        "\n",
        "Por exemplo, se você treinou um classificador para detectar vídeos seguros para crianças, provavelmente preferiria um classificador que rejeita muitos vídeos bons (baixo recall), mas mantém apenas os seguros (alta precisão), em vez de um classificador que tem muito maior recall, mas permite que alguns vídeos realmente ruins apareçam em seu produto (nesses casos, você pode até querer adicionar um pipeline humano para verificar a seleção de vídeo do classificador). \n",
        "\n",
        "Por outro lado, suponha que você treine um classificador para detectar ladrões de lojas em imagens de vigilância: provavelmente é bom se seu classificador tiver apenas 30% de precisão, desde que tenha 99% de recall (claro, os seguranças receberão alguns alertas falsos, mas quase todos os ladrões serão pegos).\n",
        "\n",
        "Infelizmente, você não pode ter as duas coisas: o aumento da precisão reduz o recall e vice-versa. Isso é chamado de tradeoff de precisão / recall.\n",
        "\n",
        "## Precisão / Recall Tradeoff\n",
        "\n",
        "Para entender essa desvantagem, vamos ver como o `SGDClassifier` toma suas decisões de classificação. \n",
        "\n",
        "Para cada instância, ele calcula uma pontuação com base em uma função de decisão e, se essa pontuação for maior que um limite, atribui a instância à classe positiva ou a atribui à classe negativa. \n",
        "\n",
        "O Scikit-Learn não permite definir o limite diretamente, mas fornece acesso às pontuações de decisão usadas para fazer previsões. Em vez de chamar o método `predict()` do classificador, você pode chamar o método `decision_function()`, que retorna uma pontuação para cada instância e, em seguida, fazer previsões com base nessas pontuações usando qualquer limite desejado:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NPesn4lPR3Xm",
        "colab_type": "code",
        "colab": {},
        "outputId": "b8d7a03b-e56d-4652-f634-cd14ae97f03b"
      },
      "source": [
        "y_scores = sgd_clf.decision_function([some_digit])\n",
        "y_scores"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([161855.74572176])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 30
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FP7t-YCwR3Xo",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "threshold = 0\n",
        "y_some_digit_pred = (y_scores > threshold)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "__kNdZrGR3Xr",
        "colab_type": "code",
        "colab": {},
        "outputId": "faaacf40-976d-4731-e252-fccd5ecb44c0"
      },
      "source": [
        "y_some_digit_pred"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ True])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KcdjyZK0R3Xt",
        "colab_type": "text"
      },
      "source": [
        "O `SGDClassifier` usa um limite igual a 0, portanto, o código anterior retorna o mesmo resultado que o método `predict()` (ou seja, True). Vamos aumentar o limite:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hpKEiRAuR3Xt",
        "colab_type": "code",
        "colab": {},
        "outputId": "25318fb5-4299-4c62-9c1f-f57d581267cd"
      },
      "source": [
        "threshold = 200000\n",
        "y_some_digit_pred = (y_scores > threshold)\n",
        "y_some_digit_pred"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([False])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FLcqkpIsR3Xv",
        "colab_type": "text"
      },
      "source": [
        "Isso confirma que aumentar o limite diminui a recuperação. A imagem realmente representa um 5, e o classificador detecta quando o limiar é 0, mas erra quando o limite é aumentado para 200.000. \n",
        "\n",
        "Então, como você pode decidir qual limite usar? Para isso, primeiro você precisa obter as pontuações de todas as instâncias no conjunto de treinamento usando a função `cross_val_predict()` novamente, mas desta vez especificando que deseja retornar os escores de decisão em vez das previsões:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3F69HLM_R3Xv",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "y_scores = cross_val_predict(sgd_clf, X_train, y_train_5, cv=3,\n",
        "                             method=\"decision_function\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TfoQbkCuR3Xy",
        "colab_type": "text"
      },
      "source": [
        "Agora, com essas pontuações, você pode calcular a precisão e o recall para todos os possíveis limites usando a função `precision_recall_curve()`:\n",
        "\n",
        "**Nota**: houve um [problema] (https://github.com/scikit-learn/scikit-learn/issues/9589) no Scikit-Learn 0.19.0 (corrigido em 0.19.1) onde o resultado de `cross_val_predict() `estava incorreto no caso de classificação binária ao usar`method=\"decision_function\"`, como no código acima. O array resultante tinha uma primeira dimensão extra cheia de 0s. Apenas no caso de você estar usando 0.19.0, precisamos adicionar este pequeno hack para contornar esse problema:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xXLLuUazR3Xy",
        "colab_type": "code",
        "colab": {},
        "outputId": "1e8125ee-a709-4411-ed3f-cfcf11d15caa"
      },
      "source": [
        "y_scores.shape"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(60000,)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 35
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MqJM5Rn4R3X1",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# hack para resolver o problema #9589 com o Scikit-Learn 0.19.0\n",
        "if y_scores.ndim == 2:\n",
        "    y_scores = y_scores[:, 1]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "P2Pib7OHR3X2",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from sklearn.metrics import precision_recall_curve\n",
        "\n",
        "precisions, recalls, thresholds = precision_recall_curve(y_train_5, y_scores)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pBQVkQNZR3X4",
        "colab_type": "code",
        "colab": {},
        "outputId": "86ac7446-e876-49c7-fc29-0af73ef1c526"
      },
      "source": [
        "def plot_precision_recall_vs_threshold(precisions, recalls, thresholds):\n",
        "    plt.plot(thresholds, precisions[:-1], \"b--\", label=\"Precisão\", linewidth=2)\n",
        "    plt.plot(thresholds, recalls[:-1], \"g-\", label=\"Recall\", linewidth=2)\n",
        "    plt.xlabel(\"Limiar\", fontsize=16)\n",
        "    plt.legend(loc=\"upper left\", fontsize=16)\n",
        "    plt.ylim([0, 1])\n",
        "\n",
        "plt.figure(figsize=(8, 4))\n",
        "plot_precision_recall_vs_threshold(precisions, recalls, thresholds)\n",
        "plt.xlim([-700000, 700000])\n",
        "plt.show()"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Saving figure precision_recall_vs_threshold_plot\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 576x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eAG832PSR3X5",
        "colab_type": "text"
      },
      "source": [
        "**Explicando o comportamento das curvas**: Por que a curva de precisão é mais irregular do que a curva de recall? \n",
        "\n",
        "A razão é que, às vezes, a precisão pode diminuir quando você aumenta o limite (embora, em geral, ele suba). Por outro lado, o recall só pode diminuir quando o limite é aumentado, o que explica por que sua curva parece suave.\n",
        "\n",
        "Agora você pode simplesmente selecionar o valor limite que lhe dá o melhor tradeoff de precisão / recall para sua tarefa."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gBPmNKw6R3X6",
        "colab_type": "code",
        "colab": {},
        "outputId": "98d36b89-be37-4657-801e-9fdf529e1ba7"
      },
      "source": [
        "(y_train_pred == (y_scores > 0)).all()"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 39
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lYhzvN3gR3X7",
        "colab_type": "text"
      },
      "source": [
        "Outra maneira de selecionar uma boa troca de precisão / recall é plotar a precisão diretamente contra o recall, como mostrado a seguir:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-cUiAE-qR3X9",
        "colab_type": "code",
        "colab": {},
        "outputId": "65fcbd46-d65b-4153-a4f7-1d5cfee101b9"
      },
      "source": [
        "def plot_precision_vs_recall(precisions, recalls):\n",
        "    plt.plot(recalls, precisions, \"b-\", linewidth=2)\n",
        "    plt.xlabel(\"Recall\", fontsize=16)\n",
        "    plt.ylabel(\"Precisão\", fontsize=16)\n",
        "    plt.axis([0, 1, 0, 1])\n",
        "\n",
        "plt.figure(figsize=(8, 6))\n",
        "plot_precision_vs_recall(precisions, recalls)\n",
        "plt.show()"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Saving figure precision_vs_recall_plot\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjgAAAGoCAYAAABL+58oAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3XmYXFW5v/37STqQmBAgAQJJgAABRIQgtggy6O8gB1GPgHpkkllAAUVQZFYm8SB6UEbFV0VmRYgiIIpHZRCHBBEEmQlDCIEMEBKGJCTr/WNVW92d7qSru6p2dfX9ua669tq7dlU9TZH0N2uvvVaklJAkSWomg4ouQJIkqdoMOJIkqekYcCRJUtMx4EiSpKZjwJEkSU3HgCNJkpqOAUeSJDWdugeciDg6IqZGxMKIuHwF5x4bETMjYl5E/CgiVq5TmZIkqR8rogdnBnA28KPlnRQRuwInAjsDE4ANgTNqXZwkSer/6h5wUko3ppR+AcxZwakHAj9MKT2UUnoZOAs4qNb1SZKk/q+l6AKWY3Pgl+327wfGRMTolFKHcBQRhwOH573R784dPrDlljBkSD1KlSRJ1XTvvffOTimt2dvXN3LAGQHMa7ff1l6FTr0/KaXLgMsA1l+/NT377FQAbrwRNtqo9oVKkqTqiohn+vL6Rg44C4CR7fbb2vOX96I114SWFnjqqZrV1cH8+TBtGsycCS+80HE7cyZ88INwyikQUZ96JElSYwech4BJwM9K+5OAFztfnqqXGTPg73+Hf/wDHn8cnnwSnngCXnxx+a+74w447TT4xS9g993rU6skSQNd3QNORLSUPncwMDgihgJvpZTe6nTqFcDlEXE18AJwKnB5bz5z8WJ48EGYNAkG9WBYdUrwyCNw++3wu9/BlCm5N6YrK68MG2wAY8fCOuvA2mvn7ZgxsP/+5fP22ANmz4bRo/P7v/xy7vl5+un8aGmBo47KW0mS1DeRUqrvB0acDnyt0+EzyLeN/wt4R0rp2dK5xwEnAMOAG4DPppQWLu/9W1tb08svT+Wpp3IPy7hx8L73wX33wY9/DAcd1P1rH3kErrwSrr4anul05W/VVWHrreFd74K3vx0mTsyPceO6D02LF8P//A989avlY1tskQPN/G4utE2aBDfc4NghSdLAFhH3ppRae/36egecWusccL7+9RxsAM46C049ddnX3HFHPu/228vH1lorj5/ZZRfYcUfYcMPejaNZtCgHomnTOh5fZZXc8zNhAtx0U9ev3XZbuPRSGDoUVl899wpJkjQQ9DXgNPUFkVtuKYcbgMGDOz7/3HNw9NHlgDFiBOy1FxxwAOywQ88uZ63ISivlMTvXX5/fb+LEHGpWX70cmFLK5xx3XK65zV/+knuM2lx9NbzxBmyzTe4JkiRJXWvqgNPWWzNkSL5cNGtW+blf/jKPkZk/P/emfPnL8PnP5+BRbYMHw957d/98BGyyCdx8cx7r88wz8L//Cz/7WX6urZNtv/3Kr/nb36C1tbHvzlq6FObMyeOOqhEWJUnqqaa+RAV50O8nPgEXX5z3Z8yAn/8cvvCFvL/77nDJJXmQcKNZtChvL7oo32r+znfC1KkdzznssFx/+8HJCxbAww/DW2/ly1zVCEEpwauv5l6v6dPzo63dtn34YfjIR8q3yr/wQjmcTZyYA+TMmfnn+ta3KvvsxYtzb5gkaWBwDE4nnQPO8cfnnpvLL8/7hx8Ol12W29/4BpxwQmP3gnR24YXlcNbel74E//pXfnQeIP2Tn+RBy1tumXurFi3KYWWNNXJ72rQ8XumJJ8q3vz/wQD7nfe+DZ5/NIWbBgur+LGPGlG+z/9jH4P/9P5g7Nx9rm0do5sy8v3BhHot0zjn52OLF8O1v5xDnbNWS1HwMOJ10Djh/+1vuAXjvezued+GFefxNf/Tyy7kn5z//s+vnV1qp3PuzIoMG5UtJPfG2t8G66+bH+PHl7fjxOQzNmZPvKltnnfIt82++mXufZszI+5dc0rPPqtTXvgY77ZRrGjky/1xt4WjMmDy+atSovP/SSx23beOiXnkFnn8e1l8/h7m252bOzHfRtbTkgeHrrZeD2KxZeX/06Nr8TJI0kBlwOmltbU3//OfUf/+Cf+utPAZmyy3hn//Mx44+Ogec/m7evNzzMX48bL45vOMd+bHhhvmX9b77drwzrCuDBuVf6BttVL71faON4M9/zu87YUJ+rLtu/iXf196uhQvze7cFjgsuyLfnL14MG2+cQ9CYMXnb1h49Ov8sw4blS4mN+t21tOT/30aOzGO8Wlry1AItLTn8zZ6dH7Nm5SD48su5/frrefqC4cOL/gkkqXEYcDppbW1N996bB6pMnJjvToKOv5jffDNP0DeQvPYa3HtvHkS90Ubw6KP5F+qECf1zbMubb+ZeljvvhBNPLH/PbVZfHVZbrePt+SNG5MC01lr5cdddOZC8+WYOwHPm5F6brbfO8yatvXYOVHfdlXuvXn89v8/Qofny3vTp1f2ZJkzIPV9z5pQfbUaPziHw1Vfz/rHH5jD78st5XqWVV84/76675mA6YkQOWq++mnub1lkn1y1J/YUBp5P2AefjH8+T5gHsuWdeLuGGG/JxNa8lS5adEmDp0urcyZVSx7D8wgs5XMycmQPP8cfn8UvtLxMOGpQD0Rpr5DFOQ4fCppvm0PLrX/e9pp5af/1c+9NP5/33vCfP0n3jjfnPhyQ1EgNOJ+0Dzqmn5sn9IF+yeeEF2GyzAovTgPPqq7k3ZXnh6s03c8h429ty6FljjbydMycHpTlz8uW8QYPyuKthw3IP1Hrr5ecfeihfQrzuumXfe8SIng0Oj8jTDlx8cT7/jTfgQx/y9n5JxTHgdNI+4Fx1Vce5Y6SB4q23cq/VSivlkHXXXTkUjRiRL7+NGJEnkvzGN3r2fquumtdTO+SQHMhmz8535I0YkS/dzZmTL4PutFPuQZszJ79mzpzcW7V4cQ5w66xT259bUvMw4HTS2tqaNt98Kn/4Q75lesSIoiuSGtdrr+VJJdvWS9t889wjVGttPVv9aYoGSfVlwOmktbU1TZkylZTsXpd6a/78PBD98cfzEiGPPJLHD02aBPffn+8Ce/75PI5n9Og8/ujBBzvObbTyyvmuueHDc5DqSttA6O22y3fXrbJKPr7HHvkmgV12ybfz77hjfj/vNJMGDgNOJ62trWlq5+l+JRXu9dfzWKG5c6vzflttlccjfeELeQ05e4Ok5mLA6cSAIzW++fPhscfybfwRuWdm5kyYPBn+8If8POQ5ndom7azEPvvkWa/b7hyT1P8YcDox4EjNZenS/PjXv/It+E8+Cb//fQ5IM2eu+PWrrZbvolxtNdhhB/jkJ/McQuPGNeYadJIyA04nBhxpYFmyBP7+97zY6zXX5Hl+Hn2056/feGP43OfyBI9LlsAWW+SxQK+/nieMtAdIKoYBpxMDjiTIl7n+8pfce3P++bkX6K9/zeN23nij5+9z7LF5/qFddzXsSPVkwOnEgCOpJ15+GS69FM44I/fUbLBBDkSQZ8JesmTZ13zgA3lZj4cegosugre/va4lSwOKAacTA46kvmhb1uPuu3Pvzdy5yx/ofNZZ+Vb5gw7KvUOSqsOA04kBR1K13XMPXHJJngjxV7/Kc/Z0paUlT5p4/PEubir1lQGnEwOOpHo455x8N9ejj3a/svxee3W9RpikFetrwHGuX0nqhZNPht/9Dp57Lq8y/9vf5h6e9n760zww+cgj83pckurHgCNJVbDLLnm5ijlz4PbbOz536aV54dMNN4TzzoN//AMWLSqmTmmgMOBIUhWNGgUf/GDu1Zk7t+MK6tOmwVe+Au96V15ba9NN4frr4W9/y2t4NdmIAalQBhxJqpHVV4cZM/KdWd/4xrLPP/YYfOpT8N73wtpr57u3IvLdW08/DW++WfeSpaZhwJGkGouAE0/MPTQp5fE466yTV1/vyne+k+flGTYsz6w8eXJ965WagQFHkuqspSX37MycWQ49S5fClVcue+6DD8LHP55D0sYb54HLklbMgCNJDSACPv3pjr08ncPME0/A3nvnc3/8Y8fsSMtjwJGkBtTSksfnLF0Kl1+eV0BvaSk/f8gheczOUUfBZz6Tb1lfurSwcqWG40R/ktSPtA1Mvv/+rp+/5JK8OrrU3znRnyQNIJtskufR+eMf4bTT4N3v7vj8kUfCVVcVUprUUOzBkaQmMHNmxzl3Ro2Cj30sr3o+fHhxdUm9ZQ+OJIm114Znny3vz52bx+6MGAE77JDH6EgDiQFHkprEuuvmgcYXXwzjxpWP/+lPeSmJCDj11DyOR2p2BhxJaiJti3tOnw533JHvvmrv61/PS0REwIQJ8PDDhZQp1ZwBR5Ka1E47wUMP5V6dM8/M43Lae+aZHIAi8t1X06cXU6dUCwYcSWpyEfmOqzlz8uSAs2fDbrt1POeoo/Ilrgj4/veLqVOqJgOOJA0wo0fDrbfmsHPDDcs+/9nP5qCz7bbw1lv1r0+qBgOOJA1gH/94eXmIp57q+Nxf/wpDhuS7sZpsRhENAAYcSRKQVzBfujQHm/XWKx8/+OC8LMTrrxdXm1QpA44k6d8iYJtt8gDk22/v+Nzw4fn5tdaCj34UbrvN9a/UuAw4kqQuffCD+dLU4Yd3PD5rFtxySx6oPHgwHHpoXh6i8yUuqUgGHEnScn3/+zno3HYbfPvbsP76HZ//0Y9g//1ho41yD8/FFxdTp9Sea1FJknrl/vvz5azVVsu3oC9Z0vH56dM7zqgsVcK1qCRJhZg0CRYuhBdfzLeT33dfx+fHj889O9dfn8+T6smAI0mqiq22ypeyWtv9m/uqq+BTn4KhQ/Plq3e8IwciqdYMOJKkqpoyJY/V2WCDZZ97+OG88rlUawYcSVLVHXdcvqsqpXwr+T33dHw+opi6NHAYcCRJNRUB22237CDkCGdIVu0YcCRJdTFo0LJrWw0aBFdeWUw9am4GHElS3QwenHtttt22fOyAA3JvzjPPFFeXmo8BR5JUd3/6Ux6n096ECbD11oWUoyZkwJEk1d2gQflOq6VL85IPbe67L/fmzJhRXG1qDgYcSVJhIuDWW2HRoo7Hx42DuXOLqUnNwYAjSSrckCF5APLee5ePbbRRcfWo/zPgSJIawuDBcO218OlP5/1XXsnrXD36qLeTq3IGHElSQ7niinJ73jx4+9vzmB2pEv4vI0lqKBGweHHXx6WeMuBIkhpOS0u+LJVSbreJcGVy9YwBR5LU0DoHmqFD4aMfdVyOls+AI0lqaG1LPAwbVj52yy35+PPPF1eXGpsBR5LU8AYPhtdfh5kzOx4fPx722aeYmtTYDDiSpH5jzJh8aeqii8rHrrvOsTlaVt0DTkSMiojJEfFaRDwTEft2c97KEfG9iHgxIuZGxK8iYly965UkNZ6jjlp2ZfKhQ/Mt5RIU04NzMbAIGAPsB1waEZt3cd4xwHbAlsBY4BXgwnoVKUlqbG0rk++1V/nYo4/CyJHLhh8NPHUNOBExHPgEcFpKaUFK6W7gJmD/Lk7fAPhNSunFlNKbwHVAV0FIkjSAXXcdvPlmeX/+/Lz0w9KlxdWk4tW7B2cTYElK6bF2x+6n6+DyQ2D7iBgbEW8j9/b8ug41SpL6mZVXhiVLOh5rW/pBA1O9A84IYF6nY/OAVbo49zHgWeB54FVgM+DMrt40Ig6PiKkRMXXWrFlVLFeS1F8MGpQHGq+0UvnYvvvCV75SXE0qTr0DzgJgZKdjI4H5XZx7KTAUGA0MB26kmx6clNJlKaXWlFLrmmuuWcVyJUn9yUor5ZDz6KPlY+edB1deWVxNKka9A85jQEtEbNzu2CTgoS7OnQRcnlKam1JaSB5gvE1ErFGHOiVJ/dgmm8Ds2eX9Aw7It5K/+mpxNam+6hpwUkqvkXtizoyI4RGxPbA70FW2ngIcEBGrRsQQ4EhgRkppdhfnSpLUwejRMGVKx2OrrprH5txxRzE1qX6KuE38SGAY8BJwLfC5lNJDEbFjRCxod96XgTeBx4FZwIeBPetdrCSp/2ptzbeSX3pp+djSpfCBD8DFFxdWluogUpOtVtba2pqmTp1adBmSpAazZAmcdRaccUb52Jw5MGpUcTWpexFxb0qptbevd6kGSdKAMHgwnH56xwU6R492vpxmZcCRJA0oY8fCueeW9wcPhunTi6tHtWHAkSQNOF/5CvzHf5T3110X5nWepU39mgFHkjQg/d//wWWXlfdXW80VyZuJAUeSNGAddhgcc0x5f+hQQ06zMOBIkga073wH9tijvD906LLrWqn/MeBIkga8yZPh858v77e05Plz1H8ZcCRJAi64ALbfvrz/8MPF1aK+M+BIklRy992w9tq5vfnmsHhxsfWo9ww4kiS1s+225fZKK3mpqr8y4EiS1M7kybDPPuX9Qf6m7Jf82iRJ6uSaazruf+pTxdSh3jPgSJLUhfaXpq6/Hr74xeJqUeUMOJIkdaP9fDjf/S6st15xtagyBhxJkroxaFDH1cafew6eeKK4etRzBhxJkpYjomPIOfvs4mpRzxlwJElagYjycg4/+Qn89a/F1qMVM+BIktQDF19cbrefK0eNyYAjSVIPjB0L3/9+eX/27OJq0YoZcCRJ6qEDDyy311wTXnqpuFq0fAYcSZJ6aOWV4eaby/tjxhRXi5bPgCNJUgU+8hHYYYfy/llnFVeLumfAkSSpQnfeWW5/9avw8MPF1aKuGXAkSapQBDz+eHn/He8orhZ1zYAjSVIvTJwIv/lNeX/nnYurRcsy4EiS1Eu77JJ7cwB+/3vYYINi61GZAUeSpF6KgPnzy/tPPw1nnllYOWrHgCNJUh8MHw6LFpX3v/Y1SKm4epQZcCRJ6qMhQ+DZZ8v7J51UXC3KDDiSJFXBuuvCFlvk9rnnwpNPFlvPQGfAkSSpStqvMj5xYnF1yIAjSVLVDBsGV15Z3v/Wt4qrZaAz4EiSVEWf/jSMH5/bxx/vgOOiGHAkSaqy++4rt3/2s+LqGMgMOJIkVdkaa8Bmm+X2PvsUW8tAZcCRJKkGjjoqb1OCn/+82FoGIgOOJEk1cMQR5fZ//zdMm1ZcLQORAUeSpBpoaYHbby/vb7hhcbUMRAYcSZJq5IMfhEsvLe//4AfF1TLQGHAkSaqhz3623D78cPjNb4qrZSAx4EiSVGPTp5fbH/oQLFlSXC0DhQFHkqQaGzcOHnigvN/SUlwtA4UBR5KkOthiC/jyl8v7gwfDW28VV0+zM+BIklQn550HY8fm9tKlMGRIsfU0MwOOJEl19NxzsOee5f0DDyyulmZmwJEkqY4GDYIbbyzvX3EF3HZbcfU0KwOOJEkFWLCg3N5tN1cdrzYDjiRJBRg+HH73u/J+29pVqg4DjiRJBdl553L7D38oro5mZMCRJKlA11yTt488UmwdzcaAI0lSgT7ykXL77LOLq6PZGHAkSSrQyJHw3vfm9mmnwbRpxdbTLAw4kiQV7Oaby+0NNyyujmZiwJEkqWBrrAHXX1/e33vv4mppFgYcSZIawCc/CZMm5fZPfwpXXllsPf2dAUeSpAYxdWq5fdJJxdXRDAw4kiQ1iJYW+N73cvv554utpb8z4EiS1EAOOqjcfuyxwsro9ww4kiQ1kJVXhlVXze2228dVOQOOJEkN5stfzttXXoE//anYWvorA44kSQ3mxBPL7R12KK6O/syAI0lSg2lpgfPPL+//4x/F1dJfGXAkSWpAxxxTbr/rXcXV0V8ZcCRJakARcPzx5f2UiqulP6p7wImIURExOSJei4hnImLf5Zy7dUTcGRELIuLFiDimu3MlSWo2Z55Zbp97bnF19EdF9OBcDCwCxgD7AZdGxOadT4qINYDbgO8Do4GJwG/rWKckSYUaOhSGDMltZzauTF0DTkQMBz4BnJZSWpBSuhu4Cdi/i9OPA36TUro6pbQwpTQ/pfRwPeuVJKloTzxRbl94YXF19Df17sHZBFiSUmo/N+P9wDI9OMC2wNyIuCciXoqIX0XEel29aUQcHhFTI2LqrFmzalC2JEnFWG89GD8+t7/whWJr6U/qHXBGAPM6HZsHrNLFueOBA4FjgPWAacC1Xb1pSumylFJrSql1zTXXrGK5kiQV75e/LLcvuKC4OvqTegecBcDITsdGAvO7OPcNYHJKaUpK6U3gDOB9EbFqjWuUJKmhbL11uX3MMbBgQXG19Bf1DjiPAS0RsXG7Y5OAh7o49wGg/U1xbe2oUW2SJDWsadPK7VW6uu6hDuoacFJKrwE3AmdGxPCI2B7YHbiyi9N/DOwZEVtFxBDgNODulNIr9atYkqTGMGECnHFGeX/x4sJK6ReKuE38SGAY8BJ5TM3nUkoPRcSOEfHvTreU0u+Bk4FbSudOBLqdM0eSpGZ3yinl9g9/WFwd/UGkJpsasbW1NU2dOrXoMiRJqontt4d77sntJvsV3kFE3JtSau3t61t6+aHvBN4PjALmAHemlB7sbRGSJKlnDj20HHDUvYoCTkS0AJcD+9BxsG+KiGuAg1JKS6pXniRJau8Tn8ghB+C112D48GLraVSVjsH5GvAp4KvABuSxNBuU9vcqbSVJUo2MHAktpe6JLbYotpZGVmnA+TRwVkrp6ymlZ0pLKDyTUvo6cDZwQPVLlCRJbSJgt91ye8aMYmtpZJUGnLHAn7t57p7S85IkqYbOOitvFy6EyZOLraVRVRpwZgDbd/Pc+0rPS5KkGmp/aerjHy+ujkZW6V1UVwOnRMTSUvsFYG1gb+AU4NzqlidJkjobNAiefx7Gjcv7r78Ob3tbsTU1mkp7cE4Hfk5eF+px8tpSTwBfb3dckiTV2NixMGRIbp98crG1NKKKAk5K6a2U0r7AFsDR5LumjgbemVLaz1vEJUmqn//6r7z97neLraMR9Wqiv5TSQ3S9QKYkSaqT88+HG2/M7faXrNTLgAMQEWsBQzsfTyk926eKJElSj6y3Xrm9007w5JPF1dJoKp3JeBB5vpsjgNW6OW1wX4uSJEk9M348TJ8OTz1VdCWNZYVjcCLiqYg4srT7ReAo4NvkpRrOIQeeacCTwGE1qlOSJHXhrrvK7auuKq6ORtOTQcYfI98lBXAwcCbl28Enp5S+BmwGPA+st+zLJUlSrUyYUG7vv39hZTScngScfcmzFANsCEwt3S31FnktKlJKi4HvAIfUokhJktS96dPL7W9+s7g6GklPAs5RwKWl9jzKA4tnAJu2O68FGFW90iRJUk+MGwcrr5zbN99cbC2NoicB56rSA+A+4B2l9m+AMyJin4j4b+AbwN+rX6IkSVqR44/P23XXLbaORrHCgJNSOoq8HAPky1Cvl9pfA2aSl2z4KTCEPOmfJEmqs623ztvf/a7YOhpFj24TTym9Wdre3u7YzIjYBtgIeBvwcGksjiRJqrPx4/P2pZfgvvvgXe8qtp6i9XqiP4CUUiKvRSVJkgr0nveU21tvDW+9BYMH8Mx0Fa1FFRG7R8TB7fbXj4g/R8T8iPh5RIyofomSJKkn2s+J0749EFW6mvipwJrt9v8XGA9cBuxEXm1ckiQVYIcdYNiw3P7FL4qtpWiVBpyNgAcAImIY8GHguJTSl4CTgT2rW54kSarEoYfm7UBfYbzSgDMUeKPUfh95DM9vS/uPAmOrVJckSeqFL32p3L7mmuLqKFqlAedpYIdSe3fg3pTSvNL+WuSJACVJUkHaL92w336FlVG4SgPO94HTI2IqcCTww3bPbQf8q1qFSZKk3rnttnL7ueeKq6NIFQWclNJ3gYOAPwOHpJR+0O7pVYAfV680SZLUG7vuWm6fempxdRQp8lQ2zaO1tTVNnTq16DIkSSrU/vvDVaWFlvrjr/qIuDel1Nrb11d6iUqSJPUDJ51Ubj/5ZHF1FGWFAScilpSWZCAilpb2u3u8VfuSJUnSimy6abk9cSLMnFlcLUXoyVINZwLT27X7YUeXJEkDy+DBcMIJcO65ef+ss+Dii4utqZ4cgyNJUhM7+GC4/PLc7k+/8us6BicihkTE8G6eGx4RQ3pbiCRJqr4jjii3//KX4uqot0oHGf8Q+EE3z32/9JAkSQ1i223L7fbz4zS7SgPOB4BfdvPcTcDOfapGkiRVXduMxjfdVGwd9VRpwFkLeKmb52YBY/pWjiRJqrZDDsnb++6DJUuKraVeKg04LwFbdPPcFsCcvpUjSZKqbccdy+0ttyyujnqqNODcDJwWER3+80TEFsApwK+qVZgkSaqOIe1uAfrXv+Chh4qrpV4qDThfBV4B7o2IeyLiZxHxJ+Dv5JXEB+iKF5IkNbb588vtd76zuDrqpdLFNmcD7wG+AQSwVWn7deA9peclSVKDGTECzj+/vH/yycXVUg9O9CdJ0gCREgwa1HG/URWy2GZErBERH42IAyNiVOnY0Ihw8U5JkhpUBPz2t+X9N94orpZaq3Qm44iI88hrU90E/AiYUHr6l+SBxpIkqUF94APl9sSJhZVRc5X2uJwEHE1edPO95PE3bX4FfLRKdUmSpBoYMgQ+8YncnjEDFiwotp5aqTTgfAY4M6V0DvnOqfaeADaqSlWSJKlmrr++3J4+vbg6aqnSgDMO6G6prkVAlwtxSpKkxhEBm2yS2806DqfSgPM80N3d85OAaX0rR5Ik1cNjj+XtmWcWW0etVBpwrge+GhHbtzuWImIT4EvAdVWrTJIk1czWW+dts85qXGnAOR14BLgTeLx07Hrgn6X9/6laZZIkqWbOOy9vH38cbrih2FpqoeKJ/iJiMLAvsCt5dfE5wG3A1Smlt6peYYWc6E+SpBVr9En/+jrRX0sFHzQE+DDwQErpSuDK3n6oJEkqVgT88Y/leXFmzICxY4usqLp6fIkqpbQY+Bnlif0kSVI/9v73l9uHHVZcHbVQ6Ricp8iXpSRJUhP45Cfz9tZbi62j2ioNON8ETomINWtRjCRJqq/2t4nPm1dcHdXW4zE4Jf8BjAKmRcRfgBeA9sOSUkrpwGoVJ0mSamuzzcrtj30M7rijuFqqqdKAsyOwGJhFXpah89IMDTYGW5Ikrchuu8Gvfw133gmvvAKrrVZ0RX1XacBpBRaklN6sRTGSJKn+bropL8IJcOiGXFilAAAUMklEQVShzTEvzgrH4ETE4Ig4PSJeAV4EXo2IGyKiCfKdJElqaYFdd83t554rtpZq6ckg488CXyWvHv4t4JfA7sD5NaxLkiTV0RFH5O2UKY036V9v9CTgHAb8IKX0HymlE1JK/w0cBXw6IlaqbXmSJKke2s+J88UvFldHtfQk4GxIXm+qvZ8Cg4H1q16RJEmqu1Gj8gNg7txia6mGngScEcCrnY7NL21XqW45kiSpKCedlLf//GexdVRDT++iGhcRG7bbH9zu+CvtT0wpPVWVyiRJUl29/e15e//9xdZRDT0NOD/v5vgvujg2uItj/xYRo4AfAv8JzAZOSilds5zzVwIeAEaklMb3rFxJklSpd7+73F64EFZeubha+qonAefgKn/mxcAiYAywFXBLRNyfUnqom/OPB14iXyqTJEk1ss465fZhh8EVVxRXS19FquO9YBExHHgZeGdK6bHSsSuB51NKJ3Zx/gbArcBx5Du5VtiD09ramqZOnVrdwiVJGiDe//48ozEUe7t4RNybUmrt7esrXWyzrzYBlrSFm5L7gc27Of9C4GTgjeW9aUQcHhFTI2LqrFmzqlOpJEkD0LXXltv33FNcHX1V74AzAui8Vuk8urgbKyL2BFpSSpNX9KYppctSSq0ppdY113Shc0mSemvs2HL7hBOKq6Ov6h1wFgAjOx0bSfm2c+Dfl7K+CXy+TnVJkqSSAw7I29mzi62jL+odcB4DWiJi43bHJgGdBxhvDEwA7oqImcCNwDoRMTMiJtShTkmSBqy2ZRteeqnYOvqi0tXE+ySl9FpE3AicGRGfId9FtTvwvk6nPgis227/fcBFwNaAg2wkSaqhrbfO27lzYdEiWKkfLsxU7x4cgCOBYeRbv68FPpdSeigidoyIBQAppbdSSjPbHsBcYGlpf0kBNUuSNGAMHVpuv/BCcXX0RV17cABSSnOBPbo4fhfdzHWTUvoj4CR/kiTVyYQJ8PTTeVbj9fvhypNF9OBIkqQG11LqAvm//yu2jt4y4EiSpGW85z15e8EFxdbRWwYcSZK0jIPbLdT02GPdn9eoDDiSJGkZu+xSbu+xzMjZxmfAkSRJXfra1/L24Yf735w4BhxJktSlk08ut48+urg6esOAI0mSurTSSrDTTrn9618XW0ulDDiSJKlbny+tCrn55sXWUSkDjiRJ6tamm+btX/8KKRVbSyUMOJIkqVtvf3u5PW1acXVUyoAjSZK6NWQIjBmT26++WmwtlTDgSJKk5RpfWg3yO98pto5KGHAkSdJyReTtww8XW0clDDiSJGm5vvKVvP3b34qtoxIGHEmStFwf+lC5/cYbxdVRCQOOJElarlVWKbd/8IPi6qiEAUeSJK1QWy/ON75RbB09ZcCRJEkrtPvueTtzZv+Y8M+AI0mSVujAA8vtU04pro6eMuBIkqQVGjYM1l03t/vDZSoDjiRJ6pHJk8vtf/2ruDp6woAjSZJ65N3vLrfbxuQ0KgOOJEnqsbPPztsnnoA5c4qtZXkMOJIkqcdOPrncbuQ5cQw4kiSpxyJgm21y+847i61leQw4kiSpIvvvn7ezZxdbx/IYcCRJUkU23jhvp0xp3En/DDiSJKkiO+1Ubjfq7eIGHEmSVJFhw2Dw4Ny+5JJia+mOAUeSJFVst93y1oAjSZKaxvHHl9uLFxdXR3cMOJIkqWLtx+FcemlxdXTHgCNJkvrkmGOKrmBZBhxJktQrl11Wbk+bVlwdXTHgSJKkXjn00HL7F78oro6uGHAkSVKvDBoERxyR28cdV2wtnRlwJElSr738ctEVdM2AI0mSeq39HVRLlhRXR2cGHEmS1GujRuWZjQF+/vNia2nPgCNJkvpk0aK8veeeYutoz4AjSZL65FOfytsLLii2jvYMOJIkqU9OO63cnj27uDraM+BIkqQ+2WyzcvsznymujvYMOJIkqc8mTszbX/6y2DraGHAkSVKf3XZb3o4aVWwdbQw4kiSpz8aMydu5c4uto40BR5Ik9dnQoeX2FVcUV0cbA44kSeqzlpZy+8Ybi6ujjQFHkiRVxUUX5W0jDDQ24EiSpKr48IfL7SeeKK4OMOBIkqQq2WADGDIkt3/yk2JrMeBIkqSq2WabvP3Od4qtw4AjSZKq5vDD83bBAkipuDoMOJIkqWr22afcnjq1uDoMOJIkqWqGDCnPZvztbxdXhwFHkiRV1Qc+kLc//WlxNRhwJElSVR1zTNEVGHAkSVKVbbdduV3UQGMDjiRJqqohQ2Dw4Nx+6aViajDgSJKkqluyJG+nTCnm8w04kiSp6trupHrttWI+34AjSZKqbvfd8/aWW4r5fAOOJEmqmcmTi/ncugeciBgVEZMj4rWIeCYi9u3mvOMj4sGImB8R0yLi+HrXKkmSeudjH8vbBQuK+fwienAuBhYBY4D9gEsjYvMuzgvgAGB14EPA0RGxd92qlCRJvbbrruX2d79b/8+PVMcb1CNiOPAy8M6U0mOlY1cCz6eUTlzBay8g1/v55Z3X2tqapha5+IUkSQIgotyuNG5ExL0ppdbefna9e3A2AZa0hZuS+4GuenD+LSIC2BF4qIa1SZKkKnr00XJ74cL6fna9A84IYF6nY/OAVVbwutPJtf64qycj4vCImBoRU2fNmtXnIiVJUt9tsgkMHZrbRxxR38+ud8BZAIzsdGwkML+7F0TE0eSxOB9JKXWZ/1JKl6WUWlNKrWuuuWbVipUkSX2z88552zbxX73UO+A8BrRExMbtjk2im0tPEXEIcCKwc0ppeh3qkyRJVXTwwXn75z/X93PrGnBSSq8BNwJnRsTwiNge2B24svO5EbEfcA6wS0rpqXrWKUmSqmPYsLx98sn6fm4Rt4kfCQwDXgKuBT6XUnooInaMiPZ3y58NjAamRMSC0uN7BdQrSZJ66b3vLbdvvrl+n9tSv4/KUkpzgT26OH4XeRBy2/4G9axLkiRV3+jRMHEiPPEE/Nd/VX67eG+5VIMkSaqp664rt+d3e1tRdRlwJElSTb373eX2QQfV5zMNOJIkqea22y5vb7yxPp9nwJEkSTV3/fXl9m231f7zDDiSJKnmxo2DNdbI7eOOq/3nGXAkSVJdHHts3j78cO0/y4AjSZLqov16VK++WtvPMuBIkqS6GD0a1lsvt9vfOl4LBhxJklQ3b72Vt7VeXdyAI0mS6uacc+rzOQYcSZJUN3vuWW4vXFi7zzHgSJKkuhk5stz+xz9q9zkGHEmSVFcbbpi3tVxd3IAjSZLqasKEvP3zn2v3GQYcSZJUVx/9aN4+9VTtPsOAI0mS6mq33fJ22jR48MHafIYBR5Ik1dWmm0JEbt9yS20+w4AjSZLqKgL22y+3p0ypzWcYcCRJUt295z15e8MNkFL139+AI0mS6u7gg8vt3/62+u9vwJEkSXW3yiowfHhu/+Qn1X9/A44kSSpEWy/OtddW/70NOJIkqRDHHltuz59f3fc24EiSpEK0LdkAMH58dd/bgCNJkgqz1155++qr1X1fA44kSSrM+eeX2/feW733NeBIkqTCrLNOub3PPtV7XwOOJEkq1Akn5O3jj1fvPQ04kiSpUO3vprr11uq8pwFHkiQVaswYWG213N577+q8pwFHkiQV7qtfzdv58+GBB/r+fgYcSZJUuC9+sdyeNKnv72fAkSRJhYuA666r3vsZcCRJUkPYay+4/fbqvJcBR5IkNYwPfhD++Me+v48BR5IkNZT3v7/v72HAkSRJTceAI0mSmo4BR5IkNR0DjiRJajoGHEmS1HQMOJIkqekYcCRJUtMx4EiSpKZjwJEkSU3HgCNJkpqOAUeSJDUdA44kSWo6BhxJktR0DDiSJKnpGHAkSVLTMeBIkqSmY8CRJElNx4AjSZKajgFHkiQ1HQOOJElqOgYcSZLUdAw4kiSp6RhwJElS0zHgSJKkpmPAkSRJTceAI0mSmo4BR5IkNR0DjiRJajp1DzgRMSoiJkfEaxHxTETs2815ERHnRsSc0uObERH1rleSJPU/LQV85sXAImAMsBVwS0Tcn1J6qNN5hwN7AJOABNwOPAV8r461SpKkfqiuPTgRMRz4BHBaSmlBSulu4CZg/y5OPxD4dkppekrpeeDbwEF1K1aSJPVb9e7B2QRYklJ6rN2x+4H3d3Hu5qXn2p+3eVdvGhGHk3t8ABZGxINVqFXVsQYwu+gi9G9+H43F76Ox+H00lk378uJ6B5wRwLxOx+YBq/Tg3HnAiIiIlFJqf2JK6TLgMoCImJpSaq1eyeoLv4/G4vfRWPw+GovfR2OJiKl9eX29BxkvAEZ2OjYSmN+Dc0cCCzqHG0mSpM7qHXAeA1oiYuN2xyYBnQcYUzo2qQfnSZIkdVDXgJNSeg24ETgzIoZHxPbA7sCVXZx+BXBcRIyLiLHAl4DLe/Axl1WrXlWF30dj8ftoLH4fjcXvo7H06fuIel/xiYhRwI+AXYA5wIkppWsiYkfg1ymlEaXzAjgX+Ezppf8fcIKXqCRJ0orUPeBIkiTVmks1SJKkpmPAkSRJTadfBhzXs2osFXwfx0fEgxExPyKmRcTx9a51IOjp99Hu/JUi4pGImF6vGgeKSr6LiNg6Iu6MiAUR8WJEHFPPWgeCCv6uWjkivlf6HuZGxK8iYly96212EXF0REyNiIURcfkKzj02ImZGxLyI+FFErLyi9++XAYeO61ntB1waEV3Nctx+PastgY8CR9SryAGkp99HAAcAqwMfAo6OiL3rVuXA0dPvo83xwEv1KGwA6tF3ERFrALcB3wdGAxOB39axzoGip382jgG2I//eGAu8AlxYryIHkBnA2eQbj7oVEbsCJwI7AxOADYEzVvTm/W6QcWk9q5eBd7Yt+RARVwLPp5RO7HTuPcDlpZmOiYhDgcNSStvWueymVcn30cVrLyD/P/j52lc6MFT6fUTEBsCtwHHAD1JK4+tZbzOr8O+qc4B1U0pdrcunKqjw+7gUmJ9S+kpp/yPA/6aU+rR0gLoWEWcD41NKB3Xz/DXA0ymlk0v7OwNXp5TWXt779scenO7Ws+oqhfd4PSv1WiXfx7+VLhXuiJM3Vlul38eFwMnAG7UubACq5LvYFpgbEfdExEulSyLr1aXKgaOS7+OHwPYRMTYi3kbu7fl1HWpU17r6XT4mIkYv70X9MeBUZT2rGtU2EFXyfbR3Ovn/vx/XoKaBrMffR0TsCbSklCbXo7ABqJI/G+OBA8mXRtYDpgHX1rS6gaeS7+Mx4FngeeBVYDPgzJpWp+Xp6nc5rOD3TH8MOK5n1Vgq+T6APLCMPBbnIymlhTWsbSDq0fdR6q7/JuDlwdqp5M/GG8DklNKUlNKb5PEF74uIVWtc40BSyfdxKTCUPB5qOHkGfntwitPV73JYzu8Z6J8Bx/WsGksl3wcRcQilwWIpJe/aqb6efh8bkwfr3RURM8l/ga9TukthQh3qHAgq+bPxAND+H15tbXubq6eS72MSefzm3NI/wi4EtikNBlf9dfW7/MWU0pzlvajfBZw6rWelHqrk+4iI/YBzgF1SSk/Vt9KBoYLv40FgXWCr0uMzwIul9nP1q7h5Vfh31Y+BPSNiq4gYApwG3J1SeqV+FTe3Cr+PKcABEbFq6fs4EpiRUppdv4qbX0S0RMRQYDAwOCKGRkRLF6deARwaEe+IiNWBU+nJ7/KUUr97AKOAXwCvka+T7ls6viP5ElTbeUHuhp9benyT0p1jPgr5PqYBi8ndjW2P7xVdf7M9evp9dHrNB4DpRdfebI9Kvgvgc+QxHy8DvyLfVVX4z9BMjwr+rhoNXE2ePuEV4G5gm6Lrb7YHeSxm6vQ4nTwObQGwXrtzjyP/I+xV8j8IVl7R+/e728QlSZJWpN9dopIkSVoRA44kSWo6BhxJktR0DDiSJKnpGHAkSVLTMeBIkqSmY8CRVBMRcVBEpHaPRRHxZEScU5rcq8jano6Iy9vtt9U6obCiJFVVVzMGSlI1/Tcwnbww3p7ASaW262BJqhkDjqRa+0dK6YlS+/bSWkCHRsQxKaWlRRYmqXl5iUpSvf0dGAb8e+HCiNggIq6OiFkRsTAi/hERe3Z+YURMiojJETEnIt6IiEcj4qR2z/9nRNwaES9ExOsR8WBEfCkiBtfnR5PUKOzBkVRvE4B5wByAiFgX+Ct53Z9jgVnAXsANEbFHSumm0nnbAH8EniidN528KvqW7d57Q+D/yKs/vwm0kte2WZO8ir2kAcKAI6nWBpdWCG4bg/MJ4IsppSWl508nL4z7/pTSnNKx35SCz5nATaVj3yKHom1TSq+Xjv2+/QellL7X1o6IAO4CVgK+HBEne0lMGjgMOJJq7ZFO+5eklC5qt/8h4FZgXikItfkNcF5EjATeArYHzmsXbpYREeuQA9OHgLF0/DtuLWBmb38ISf2LAUdSre1Jvpy0JnAccGRE/DWldEXp+bWAA0qProwGFpHHDE7v7kMiYhC5t2csOeQ8ArwB7AGcAhR6a7qk+jLgSKq1B9vuooqI3wMPkHtmbkgpvUa+7HQXcG43r58BDAaWAuOW8zkbkcfc7J9SuqrtYET8V99/BEn9jXdRSaqblNJC4Hhyr82RpcO3kQcKP5RSmtrFY2HpstTdwKcjYlg3b/+20nZx24GIGALsV5MfRlJDswdHUl2llG6KiCnkgb8XAV8F/gbcWdp/GlgdeCewYUrpkNJLvwzcAfw5Ir5Nvly1IbBVSunzwMPAM8DXI2IJOegcW7+fTFIjsQdHUhFOJffifDal9Cz50tL9wDnA7cClwPtpd5dUSmkKeaDxc+TbwG8l9wZNLz2/iDzeZiZwBXAxcCfwP3X5iSQ1lEgpFV2DJElSVdmDI0mSmo4BR5IkNR0DjiRJajoGHEmS1HQMOJIkqekYcCRJUtMx4EiSpKZjwJEkSU3n/wfceSEoxw0z0QAAAABJRU5ErkJggg==\n",
            "text/plain": [
              "<Figure size 576x432 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d4U7NkWHR3X_",
        "colab_type": "text"
      },
      "source": [
        "Você pode ver que a precisão realmente começa a cair drasticamente em torno de 80%. Você provavelmente desejará selecionar um tradeoff de precisão / recall logo antes da queda - por exemplo, com cerca de 60% de recall. Mas é claro que a escolha depende do seu projeto. \n",
        "\n",
        "Então, suponhamos que você tenha a meta de 90% de precisão. Você procura no primeiro gráfico (ampliando um pouco) e descobre que precisa usar um limite de cerca de 70.000. Para fazer previsões (no conjunto de treinamento, por enquanto), em vez de chamar o método `predict()` do classificador, basta executar este código:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "P2xufe_ZR3X_",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "y_train_pred_90 = (y_scores > 70000)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AkZ4VTBDR3YB",
        "colab_type": "code",
        "colab": {},
        "outputId": "faebf467-ab90-4cce-a2bc-0c0cdb0099a5"
      },
      "source": [
        "precision_score(y_train_5, y_train_pred_90)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.8659205116491548"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 42
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ChTtMVhYR3YD",
        "colab_type": "code",
        "colab": {},
        "outputId": "c2cde541-198e-4baf-e2a8-7bc5822bccbf"
      },
      "source": [
        "recall_score(y_train_5, y_train_pred_90)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.6993174691016417"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 43
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gNPsGzEdR3YF",
        "colab_type": "text"
      },
      "source": [
        "Ótimo, você tem um classificador de precisão de >85%! Como você pode ver, é bastante fácil criar um classificador com praticamente qualquer precisão desejada: basta definir um limite suficientemente alto e pronto!\n",
        "\n",
        "**Lembrando**: Um classificador de alta precisão não é muito útil se o seu recall for muito baixo! Se alguém disser \"vamos chegar a 99% de precisão\", você deve perguntar \"a que recall?\""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SUmU997mR3YG",
        "colab_type": "text"
      },
      "source": [
        "# ROC curves\n",
        "\n",
        "A curva característica de operação do receptor (ROC) é outra ferramenta comum usada classificadores binários. \n",
        "\n",
        "É muito semelhante à curva de precisão / recall, mas em vez de plotar precisão versus recall, a curva ROC traça a taxa positiva verdadeira (outro nome para recall) contra a taxa de falsos positivos (FPR). \n",
        "\n",
        "O FPR é a proporção de instâncias negativas que são incorretamente classificadas como positivas. É igual a um menos a taxa real negativa, que é a proporção de instâncias negativas que são corretamente classificadas como negativas (TNR). \n",
        "\n",
        "O TNR também é chamado de especificidade. Portanto, a curva ROC plota:\n",
        "\n",
        "sensibilidade versus (1 - especificidade).\n",
        "\n",
        "Para plotar a curva ROC, primeiro você precisa calcular o TPR e o FPR para vários valores de limite, usando a função `roc_curve()`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "01KGfnuTR3YG",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from sklearn.metrics import roc_curve\n",
        "\n",
        "fpr, tpr, thresholds = roc_curve(y_train_5, y_scores)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9McNbhwbR3YH",
        "colab_type": "code",
        "colab": {},
        "outputId": "d86a43f3-4934-4e48-9127-defd4500eddc"
      },
      "source": [
        "def plot_roc_curve(fpr, tpr, label=None):\n",
        "    plt.plot(fpr, tpr, linewidth=2, label=label)\n",
        "    plt.plot([0, 1], [0, 1], 'k--')\n",
        "    plt.axis([0, 1, 0, 1])\n",
        "    plt.xlabel('False Positive Rate', fontsize=16)\n",
        "    plt.ylabel('True Positive Rate', fontsize=16)\n",
        "\n",
        "plt.figure(figsize=(8, 6))\n",
        "plot_roc_curve(fpr, tpr)\n",
        "plt.show()"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Saving figure roc_curve_plot\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 576x432 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lnyYXEl2R3YJ",
        "colab_type": "text"
      },
      "source": [
        "Mais uma vez, existe um tradeoff: quanto maior o recall (TPR), mais falsos positivos (FPR) o classificador produz. \n",
        "\n",
        "A linha pontilhada representa a curva ROC de um classificador puramente aleatório; um bom classificador fica o mais longe possível dessa linha (em direção ao canto superior esquerdo). \n",
        "\n",
        "Uma maneira de comparar os classificadores é medir a área sob a curva (AUC). Um classificador perfeito terá uma AUC ROC igual a 1, enquanto um classificador puramente aleatório terá uma AUC ROC igual a 0,5. \n",
        "\n",
        "O Scikit-Learn fornece uma função para calcular a AUC do ROC:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nwsLAJiJR3YK",
        "colab_type": "code",
        "colab": {},
        "outputId": "6df36dd9-2097-45c9-a7f9-92f0ed93d994"
      },
      "source": [
        "from sklearn.metrics import roc_auc_score\n",
        "\n",
        "roc_auc_score(y_train_5, y_scores)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.9624496555967155"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 46
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4c79XNr_R3YM",
        "colab_type": "text"
      },
      "source": [
        "Como a curva ROC é tão semelhante à curva de precisão / recall (ou PR), você pode se perguntar como decidir qual delas usar. \n",
        "\n",
        "Como regra geral, você deve preferir a curva PR sempre que a classe positiva for rara ou quando você se importar mais com os falsos positivos do que com os falsos negativos e a curva ROC no caso contrário.\n",
        "\n",
        "Por exemplo, olhando para a curva ROC anterior (e a pontuação ROC AUC), você pode pensar que o classificador é realmente bom. Mas isso é principalmente porque existem poucos positivos (5s) em comparação com os negativos (não-5s). \n",
        "\n",
        "Em contraste, a curva PR deixa claro que o classificador tem espaço para melhorias (a curva pode estar mais próxima do canto superior direito).\n",
        "\n",
        "\n",
        "Vamos treinar um `RandomForestClassifier` e comparar sua curva ROC e pontuação ROC AUC para o `SGDClassifier`. \n",
        "\n",
        "Primeiro, você precisa obter pontuações para cada instância no conjunto de treinamento. Mas devido à maneira como funciona, o classificador `RandomForestClassifier` não possui um método `decision_function()`. \n",
        "\n",
        "Em vez disso, ele tem um método pre `dict_proba()`. \n",
        "\n",
        "Os classificadores do Scikit-Learn geralmente possuem um ou outro. \n",
        "\n",
        "O método `predict_proba()` retorna uma matriz contendo uma linha por instância e uma coluna por classe, cada uma contendo a probabilidade de que a instância determinada pertença à classe determinada (por exemplo, 70% de chance de a imagem representar um 5):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "c9J4H-gwR3YM",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from sklearn.ensemble import RandomForestClassifier\n",
        "forest_clf = RandomForestClassifier(n_estimators=10, random_state=42)\n",
        "y_probas_forest = cross_val_predict(forest_clf, X_train, y_train_5, cv=3,\n",
        "                                    method=\"predict_proba\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ug3_079-R3YO",
        "colab_type": "text"
      },
      "source": [
        "**Nota**: nós definimos `n_estimators = 10` para evitar um aviso sobre o fato de que seu valor padrão será ajustado para 100 no Scikit-Learn 0.22.\n",
        "\n",
        "\n",
        "Mas para plotar uma curva ROC, você precisa de pontuações, não de probabilidades. Uma solução simples é usar a probabilidade da classe positiva como a pontuação:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SO90cqbOR3YO",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "y_scores_forest = y_probas_forest[:, 1] # score = proba of positive class\n",
        "fpr_forest, tpr_forest, thresholds_forest = roc_curve(y_train_5,y_scores_forest)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mdMxER3TR3YP",
        "colab_type": "code",
        "colab": {},
        "outputId": "80dc6f4f-aece-4041-d854-bca22a66c7b5"
      },
      "source": [
        "plt.figure(figsize=(8, 6))\n",
        "plt.plot(fpr, tpr, \"b:\", linewidth=2, label=\"SGD\")\n",
        "plot_roc_curve(fpr_forest, tpr_forest, \"Random Forest\")\n",
        "plt.legend(loc=\"lower right\", fontsize=16)\n",
        "plt.show()"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Saving figure roc_curve_comparison_plot\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 576x432 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "l_vIS4csR3YR",
        "colab_type": "text"
      },
      "source": [
        "Como você pode ver, a curva ROC do `RandomForestClassifier` parece muito melhor do que a do `SGDClassifier`: ela fica muito mais próxima do canto superior esquerdo. \n",
        "\n",
        "Como resultado, sua pontuação na ROC AUC também é significativamente melhor:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "o99nTyPKR3YS",
        "colab_type": "code",
        "colab": {},
        "outputId": "c1bca00f-597d-45b1-b0e8-a3005fc982e9"
      },
      "source": [
        "roc_auc_score(y_train_5, y_scores_forest)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.9931243366003829"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 50
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GoXq-cKuR3YV",
        "colab_type": "code",
        "colab": {},
        "outputId": "1e6133c9-c688-4011-fc78-8cb4df855fe7"
      },
      "source": [
        "y_train_pred_forest = cross_val_predict(forest_clf, X_train, y_train_5, cv=3)\n",
        "print('precisão:', precision_score(y_train_5, y_train_pred_forest))\n",
        "print('recall:', recall_score(y_train_5, y_train_pred_forest))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "precisão: 0.9852973447443494\n",
            "recall: 0.8282604685482383\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hISRzBQpR3YY",
        "colab_type": "text"
      },
      "source": [
        "Medindo a precisão e as pontuações de recall: encontramos 98,5% de precisão e 82,8% de recall. \n",
        "\n",
        "Com isso, encerramos os classificadores binários!\n",
        "\n",
        "**Dica**: Sempre que for treinar classificadores binários, escolha a métrica apropriada para sua tarefa, avalie seus classificadores usando validação cruzada, selecione a troca de precisão / recall que atenda às suas necessidades e compare vários modelos usando curvas ROC e pontuações ROC AUC. \n",
        "\n",
        "\n",
        "Agora vamos tentar detectar mais do que apenas os 5s com Classificação Multiclasse."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S1oNjTH9R3YZ",
        "colab_type": "text"
      },
      "source": [
        "# Classificação Multiclasse\n",
        "\n",
        "Enquanto os classificadores binários distinguem entre duas classes (0, 1), os classificadores multiclasse (também chamados de classificadores multinomiais) podem distinguir entre mais de duas classes.\n",
        "\n",
        "\n",
        "Alguns algoritmos (como classificadores Random Forest ou classificadores Naive Bayes) são capazes de lidar com várias classes diretamente. Outros (como classificadores Support Vector Machine ou classificadores lineares) são classificadores estritamente binários. \n",
        "\n",
        "No entanto, existem várias estratégias que você pode usar para executar a classificação multiclasse usando vários classificadores binários.\n",
        "\n",
        "Por exemplo, uma maneira de criar um sistema que possa classificar as imagens digitadas em 10 classes (de 0 a 9) é treinar 10 classificadores binários, um para cada dígito (um detector de 0, um detector de 1, um detector de 2 e assim por diante). \n",
        "\n",
        "Então, quando você deseja classificar uma imagem, você obtém a pontuação de decisão de cada classificador para essa imagem e seleciona a classe cujo classificador gera a pontuação mais alta. Isso é chamado de estratégia one-versus-all (OvA) (também chamado de one-versus-rest).\n",
        "\n",
        "Outra estratégia é treinar um classificador binário para cada par de dígitos: um para distinguir 0s e 1s, outro para distinguir 0s e 2s, outro para 1s e 2s, e assim por diante. Isso é chamado de estratégia de one-versus-one (OvO). \n",
        "\n",
        "Se houver classes N, você precisa treinar classificadores N × (N - 1) / 2. \n",
        "\n",
        "Para o problema MNIST, isso significa treinar 45 classificadores binários! \n",
        "\n",
        "Quando você quer classificar uma imagem, você tem que executar a imagem através de todos os 45 classificadores e ver qual classe vence a maioria dos duelos. \n",
        "\n",
        "A principal vantagem do OvO é que cada classificador só precisa ser treinado por parte do conjunto de treinamento para as duas classes que ele deve distinguir.\n",
        "\n",
        "Alguns algoritmos (como os classificadores Support Vector Machine) têm um escalonamento ruim com o tamanho do dataset, portanto, para esses casos, o OvO é preferido, pois é mais rápido treinar muitos classificadores em datasets pequenos do que treinar poucos classificadores em grandes datasets. \n",
        "\n",
        "Para a maioria dos algoritmos de classificação binária, no entanto, o OvA é o preferido. \n",
        "\n",
        "O Scikit-Learn detecta quando você tenta usar um algoritmo de classificação binária para uma tarefa de classificação multiclasse e executa automaticamente o OvA (exceto para os classificadores SVM para os quais ele usa o OvO). \n",
        "\n",
        "Vamos tentar isso com o `SGDClassifier`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7GScSXr-R3Ya",
        "colab_type": "code",
        "colab": {},
        "outputId": "2afec2c9-4448-430f-8fd3-dfeb8ed5045b"
      },
      "source": [
        "sgd_clf.fit(X_train, y_train)\n",
        "sgd_clf.predict([some_digit])"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([5.])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 52
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RMM-apgIR3Yc",
        "colab_type": "text"
      },
      "source": [
        "Esse código treina o `SGDClassifier` no dataset usando as classes de destino originais de 0 a 9 (y_train), em vez das classes de destino 5 versus todas (y_train_5). \n",
        "\n",
        "E então faz uma previsão (correta neste caso). No backend, o Scikit-Learn realmente treinou 10 classificadores binários, obteve suas pontuações de decisão para a imagem e selecionou a classe com a maior pontuação. \n",
        "\n",
        "Para ver que este é realmente o caso, você pode chamar o método `decision_function()`. \n",
        "\n",
        "Em vez de retornar apenas uma pontuação por instância, agora retorna 10 pontuações, uma por turma:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xY80R4RmR3Yd",
        "colab_type": "code",
        "colab": {},
        "outputId": "c9cc5abe-dd03-4cad-8761-d29121e681e1"
      },
      "source": [
        "some_digit_scores = sgd_clf.decision_function([some_digit])\n",
        "some_digit_scores"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[-311402.62954431, -363517.28355739, -446449.5306454 ,\n",
              "        -183226.61023518, -414337.15339485,  161855.74572176,\n",
              "        -452576.39616343, -471957.14962573, -518542.33997148,\n",
              "        -536774.63961222]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 53
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AlT1f407R3Yf",
        "colab_type": "text"
      },
      "source": [
        "E com isso confirmamos que a classe 5 tem o maior score"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DUryH2j4R3Yf",
        "colab_type": "code",
        "colab": {},
        "outputId": "c09d0c5c-0ab4-4537-d5fb-c77cd2a3ab9a"
      },
      "source": [
        "np.argmax(some_digit_scores)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 54
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xYGnR51JR3Yh",
        "colab_type": "code",
        "colab": {},
        "outputId": "d8756133-5531-46dd-f11a-f8cb429285d5"
      },
      "source": [
        "sgd_clf.classes_"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 55
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rndqwoedR3Yk",
        "colab_type": "code",
        "colab": {},
        "outputId": "718dbce7-cf79-4a67-8353-89389ec5ef5b"
      },
      "source": [
        "sgd_clf.classes_[5]"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5.0"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 56
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VW1YDTPNR3Ym",
        "colab_type": "text"
      },
      "source": [
        "**Nota**: Quando um classificador é treinado, ele armazena a lista de classes de destino em seu classes_attribute, ordenada por valor. Nesse caso, o índice de cada classe no classes_array corresponde à classe propriamente dita (por exemplo, a classe no índice 5 passa a ser classe 5), mas em geral isso nem sempre acontece!\n",
        "\n",
        "\n",
        "Se você quer forçar o ScikitLearn a usar um contra um ou um contra tudo, você pode usar as classes `OneVsOneClassifier` ou `OneVsRestClassifier`. \n",
        "\n",
        "Basta criar uma instância e passar um classificador binário para seu construtor. \n",
        "\n",
        "Por exemplo, este código cria um classificador multiclasse usando a estratégia OvO, baseada em um `SGDClassifier`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CbX281O0R3Ym",
        "colab_type": "code",
        "colab": {},
        "outputId": "16a80198-da32-4833-94a2-cfebc853767c"
      },
      "source": [
        "from sklearn.multiclass import OneVsOneClassifier\n",
        "ovo_clf = OneVsOneClassifier(SGDClassifier(max_iter=5, tol=-np.infty, random_state=42))\n",
        "ovo_clf.fit(X_train, y_train)\n",
        "ovo_clf.predict([some_digit])"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([5.])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 57
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MiEuwrtER3Yo",
        "colab_type": "code",
        "colab": {},
        "outputId": "6ad94105-0976-4a71-8b81-37d1a449d0d0"
      },
      "source": [
        "len(ovo_clf.estimators_)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "45"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 58
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Z2weCN-cR3Yp",
        "colab_type": "text"
      },
      "source": [
        "E treinando um `RandomForestClassifier` da mesma forma:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-qc5XQB2R3Yp",
        "colab_type": "code",
        "colab": {},
        "outputId": "2deb2ddb-a9e2-48cc-f128-f1eda64ec864"
      },
      "source": [
        "forest_clf.fit(X_train, y_train)\n",
        "forest_clf.predict([some_digit])"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([5.])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 59
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "R-Emj2eDR3Yr",
        "colab_type": "text"
      },
      "source": [
        "Desta vez, o Scikit-Learn não precisou executar OvA ou OvO porque os classificadores Random Forest podem classificar diretamente as instâncias em várias classes. \n",
        "\n",
        "Você pode chamar `predict_proba()` para obter a lista de probabilidades que o classificador atribuiu a cada instância para cada classe:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "goGIrVm_R3Yr",
        "colab_type": "code",
        "colab": {},
        "outputId": "cf1487b8-df5d-4909-d5c2-425761b36288"
      },
      "source": [
        "forest_clf.predict_proba([some_digit])"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0.1, 0. , 0. , 0.1, 0. , 0.8, 0. , 0. , 0. , 0. ]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 60
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iIZcNhKXR3Ys",
        "colab_type": "text"
      },
      "source": [
        "Você pode ver que o classificador está bastante confiante em relação à sua previsão: o 0,8 no 5º índice da matriz significa que o modelo estima uma probabilidade de 80% de que a imagem seria um numero 5. Tambem podemos notar um 10% chance da imagem ser classificada como 0 ou 3.\n",
        "\n",
        "Agora, para avaliar esses classificadores, como de costume, vamos avaliar a precisão do `SGDClassifier` usando a função `cross_val_score()`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PD23CUEYR3Yt",
        "colab_type": "code",
        "colab": {},
        "outputId": "29e2ac02-d6ce-4f52-e385-cf4305372908"
      },
      "source": [
        "cross_val_score(sgd_clf, X_train, y_train, cv=3, scoring=\"accuracy\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0.84063187, 0.84899245, 0.86652998])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 61
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QDp09PNdR3Yu",
        "colab_type": "text"
      },
      "source": [
        "O classificador obtém mais de 84% em todas as dobras de teste. Se você usou um classificador aleatório, você obteria 10% de precisão, então essa não é uma pontuação tão ruim, mas ainda podemos fazer muito melhor. \n",
        "\n",
        "Por exemplo, simplesmente escalar as entradas (como discutido na aula anterior) aumenta a precisão acima de 90%, como podemos ver:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WYhVLWAFR3Yu",
        "colab_type": "code",
        "colab": {},
        "outputId": "9fc91e92-bb3b-4f18-aaff-4b05d35fb5b5"
      },
      "source": [
        "from sklearn.preprocessing import StandardScaler\n",
        "scaler = StandardScaler()\n",
        "X_train_scaled = scaler.fit_transform(X_train.astype(np.float64))\n",
        "cross_val_score(sgd_clf, X_train_scaled, y_train, cv=3, scoring=\"accuracy\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0.91011798, 0.90874544, 0.906636  ])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 62
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "okaBmgmNR3Yw",
        "colab_type": "text"
      },
      "source": [
        "## Erro de análise\n",
        "\n",
        "Naturalmente, se este fosse um projeto real, você seguiria as etapas da sua lista de verificação de aprendizado de máquina:\n",
        "\n",
        "-explorando opções de preparação de dados;\n",
        "\n",
        "-experimentando vários modelos;\n",
        "\n",
        "-selecionando os melhores e ajustando seus hiperparâmetros usando `GridSearchCV`;\n",
        "\n",
        "-automatizando o máximo possível;\n",
        "\n",
        "Aqui, vamos supor que você encontrou um modelo promissor e deseja encontrar maneiras de melhorá-lo. \n",
        "\n",
        "Uma maneira de fazer isso é analisar os tipos de erros cometidos. \n",
        "\n",
        "Primeiro, você pode ver a matriz de confusão. Você precisa fazer previsões usando a função `cross_val_predict()` e, em seguida, chamar a função `confusion_matrix()`, assim como fizemos anteriormente:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oM-DR0u0R3Yx",
        "colab_type": "code",
        "colab": {},
        "outputId": "2c2e00ab-e669-4513-9bf8-f02d89285b4f"
      },
      "source": [
        "y_train_pred = cross_val_predict(sgd_clf, X_train_scaled, y_train, cv=3)\n",
        "conf_mx = confusion_matrix(y_train, y_train_pred)\n",
        "conf_mx"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[5725,    3,   24,    9,   10,   49,   50,   10,   39,    4],\n",
              "       [   2, 6493,   43,   25,    7,   40,    5,   10,  109,    8],\n",
              "       [  51,   41, 5321,  104,   89,   26,   87,   60,  166,   13],\n",
              "       [  47,   46,  141, 5342,    1,  231,   40,   50,  141,   92],\n",
              "       [  19,   29,   41,   10, 5366,    9,   56,   37,   86,  189],\n",
              "       [  73,   45,   36,  193,   64, 4582,  111,   30,  193,   94],\n",
              "       [  29,   34,   44,    2,   42,   85, 5627,   10,   45,    0],\n",
              "       [  25,   24,   74,   32,   54,   12,    6, 5787,   15,  236],\n",
              "       [  52,  161,   73,  156,   10,  163,   61,   25, 5027,  123],\n",
              "       [  43,   35,   26,   92,  178,   28,    2,  223,   82, 5240]],\n",
              "      dtype=int64)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 63
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2crzzmyUR3Yz",
        "colab_type": "text"
      },
      "source": [
        "Isso é um monte de números. \n",
        "\n",
        "Muitas vezes, é mais conveniente observar uma representação de imagem da matriz de confusão, usando a `função matshow()` do Matplotlib:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sNUu7GF4R3Yz",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def plot_confusion_matrix(matrix):\n",
        "    \"\"\"If you prefer color and a colorbar\"\"\"\n",
        "    fig = plt.figure(figsize=(8,8))\n",
        "    ax = fig.add_subplot(111)\n",
        "    cax = ax.matshow(matrix)\n",
        "    fig.colorbar(cax)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UuYSQDCsR3Y0",
        "colab_type": "code",
        "colab": {},
        "outputId": "f03f42a5-c041-4456-e7c7-4a8461ae4020"
      },
      "source": [
        "plt.matshow(conf_mx, cmap=plt.cm.gray)\n",
        "save_fig(\"confusion_matrix_plot\", tight_layout=False)\n",
        "plt.show()"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Saving figure confusion_matrix_plot\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 288x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0YCoOeiaR3Y2",
        "colab_type": "text"
      },
      "source": [
        "Essa matriz de confusão parece bastante boa, já que a maioria das imagens está na diagonal principal, o que significa que elas foram classificadas corretamente. \n",
        "\n",
        "Os 5s parecem um pouco mais escuros do que os outros dígitos, o que pode significar que há menos imagens de 5s no conjunto de dados ou que o classificador não executa tão bem em 5s quanto em outros dígitos.\n",
        "\n",
        "Na verdade, podemos verificar se ambos são o caso. \n",
        "\n",
        "Vamos focar o plot nos erros. \n",
        "\n",
        "Primeiro, você precisa dividir cada valor na matriz de confusão pelo número de imagens na classe correspondente, para que você possa comparar as taxas de erro em vez do número absoluto de erros (o que faria com que classes abundantes parecessem injustamente ruins):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lR1rOwrKR3Y2",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "row_sums = conf_mx.sum(axis=1, keepdims=True)\n",
        "norm_conf_mx = conf_mx / row_sums"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2yz1YmAXR3Y7",
        "colab_type": "text"
      },
      "source": [
        "Agora vamos preencher a diagonal com zeros para manter apenas os erros, e vamos plotar o resultado:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "k6BRwsg_R3Y8",
        "colab_type": "code",
        "colab": {},
        "outputId": "43044f28-e1bb-4cab-dd18-545f538eb796"
      },
      "source": [
        "np.fill_diagonal(norm_conf_mx, 0)\n",
        "plt.matshow(norm_conf_mx, cmap=plt.cm.gray)\n",
        "save_fig(\"confusion_matrix_errors_plot\", tight_layout=False)\n",
        "plt.show()"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Saving figure confusion_matrix_errors_plot\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 288x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aOOoY0iaR3Y9",
        "colab_type": "text"
      },
      "source": [
        "Agora podemos ver claramente os tipos de erros que o classificador faz. \n",
        "\n",
        "Lembrando que as linhas representam classes reais, enquanto as colunas representam as classes previstas. \n",
        "\n",
        "As colunas das classes 8 e 9 são bastante claras, o que indica que muitas imagens são classificadas erroneamente como 8s ou 9s. \n",
        "\n",
        "Da mesma forma, as linhas das classes 8 e 9 também são bastante brilhantes, informando que 8s e 9s são frequentemente confundidos com outros dígitos. \n",
        "\n",
        "Por outro lado, algumas linhas são muito escuras, como a linha 1: isso significa que a maioria dos 1s é classificada corretamente (alguns são confundidos com 8s, mas isso é tudo). \n",
        "\n",
        "Observe que os erros não são perfeitamente simétricos; Por exemplo, há mais 5s incorretamente classificados como 8s do que o inverso. \n",
        "\n",
        "Analisar a matriz de confusão muitas vezes pode fornecer informações sobre maneiras de melhorar seu classificador.\n",
        "\n",
        "Olhando para estes resultados, parece que os nossos esforços devem ser gastos na melhoria da classificação de 8s e 9s, bem como corrigir a confusão específica de 3 e 5. \n",
        "\n",
        "Por exemplo, podemos tentar reunir mais dados de treinamento para esses dígitos. \n",
        "\n",
        "Ou você poderia criar novos recursos que ajudariam o classificador - por exemplo, escrever um algoritmo para contar o número de loops fechados (por exemplo, 8 tem dois, 6 tem um, 5 não tem nenhum). Ou você poderia pré-processar as imagens (por exemplo, usando Scikit-Image, Pillow ou OpenCV) para destacar alguns padrões, como loops fechados.\n",
        "\n",
        "A análise de erros individuais também pode ser uma boa maneira de obter insights sobre o que seu classificador está fazendo e por que está falhando, mas é mais difícil e demorado. \n",
        "\n",
        "Por exemplo, vamos traçar exemplos de 3s e 5s:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HPeUfsdBR3Y-",
        "colab_type": "code",
        "colab": {},
        "outputId": "ca2767b8-7f11-4589-eb20-598bdb24f0fd"
      },
      "source": [
        "cl_a, cl_b = 3, 5\n",
        "X_aa = X_train[(y_train == cl_a) & (y_train_pred == cl_a)]\n",
        "X_ab = X_train[(y_train == cl_a) & (y_train_pred == cl_b)]\n",
        "X_ba = X_train[(y_train == cl_b) & (y_train_pred == cl_a)]\n",
        "X_bb = X_train[(y_train == cl_b) & (y_train_pred == cl_b)]\n",
        "\n",
        "plt.figure(figsize=(8,8))\n",
        "plt.subplot(221); plot_digits(X_aa[:25], images_per_row=5)\n",
        "plt.subplot(222); plot_digits(X_ab[:25], images_per_row=5)\n",
        "plt.subplot(223); plot_digits(X_ba[:25], images_per_row=5)\n",
        "plt.subplot(224); plot_digits(X_bb[:25], images_per_row=5)\n",
        "save_fig(\"error_analysis_digits_plot\")\n",
        "plt.show()"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Saving figure error_analysis_digits_plot\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 576x576 with 4 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BZLzAEyNR3ZC",
        "colab_type": "text"
      },
      "source": [
        "Os dois blocos 5 × 5 à esquerda mostram dígitos classificados como 3s e os dois blocos 5 × 5 à direita mostram imagens classificadas como 5s. \n",
        "\n",
        "Alguns dos dígitos que o classificador erra (ou seja, nos blocos inferior esquerdo e superior direito) são tão mal escritos que até um ser humano teria dificuldade em classificá-los (por exemplo, os 5 na 8ª linha e na 1ª coluna realmente parecem como um 3). \n",
        "\n",
        "No entanto, a maioria das imagens equivocadas parece ser um erro óbvio para nós, e é difícil entender por que o classificador cometeu os erros cometidos. \n",
        "\n",
        "O motivo é que usamos um `SGDClassifier` simples, que é um modelo linear. Tudo o que faz é atribuir um peso por classe a cada pixel e, quando vê uma nova imagem, resume as intensidades de pixels ponderadas para obter uma pontuação para cada classe. \n",
        "\n",
        "Então, como 3s e 5s diferem apenas por alguns pixels, esse modelo irá facilmente confundi-los.\n",
        "\n",
        "A principal diferença entre 3s e 5s é a posição da pequena linha que une a linha superior ao arco inferior. \n",
        "\n",
        "Se você desenhar um 3 com a junção levemente deslocada para a esquerda, o classificador poderá classificá-lo como 5 e vice-versa. \n",
        "\n",
        "Em outras palavras, esse classificador é bastante sensível à mudança e rotação de imagens. \n",
        "\n",
        "Portanto, uma maneira de reduzir a confusão 3/5 seria pré-processar as imagens para garantir que elas sejam bem centralizadas e não giradas demais. \n",
        "\n",
        "Isso provavelmente ajudará a reduzir outros erros também."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pampMtbtR3ZC",
        "colab_type": "text"
      },
      "source": [
        "# Classificação Multilabel\n",
        "\n",
        "Até agora, cada instância sempre foi atribuída a apenas uma classe. Em alguns casos você pode querer que seu classificador envie várias classes para cada instância. \n",
        "\n",
        "Por exemplo, considere um classificador de reconhecimento de rosto: o que ele deve fazer se reconhecer várias pessoas na mesma imagem? Claro que deve anexar um rótulo por pessoa que reconhece. \n",
        "\n",
        "Digamos que o classificador tenha sido treinado para reconhecer três rostos, Ana, Rogerio e Carlos; então quando é mostrada uma foto de Ana e Carlos, deve sair [1, 0, 1] (significando “Ana sim, Rogerio não, Carlos sim”). \n",
        "\n",
        "Tal sistema de classificação que gera múltiplos rótulos binários é chamado de sistema de classificação multi-rótulo.\n",
        "\n",
        "Ainda não vamos ao reconhecimento facial, mas vamos ver um exemplo mais simples, apenas como prova de conceito:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lq8b92E8R3ZC",
        "colab_type": "code",
        "colab": {},
        "outputId": "e0bb44a9-ca21-450b-a5f6-6e31bb77321f"
      },
      "source": [
        "from sklearn.neighbors import KNeighborsClassifier\n",
        "\n",
        "y_train_large = (y_train >= 7)\n",
        "y_train_odd = (y_train % 2 == 1)\n",
        "y_multilabel = np.c_[y_train_large, y_train_odd]\n",
        "\n",
        "knn_clf = KNeighborsClassifier()\n",
        "knn_clf.fit(X_train, y_multilabel)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',\n",
              "           metric_params=None, n_jobs=1, n_neighbors=5, p=2,\n",
              "           weights='uniform')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 69
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FyxvFh_VR3ZE",
        "colab_type": "text"
      },
      "source": [
        "Esse código cria um array y_multilabel contendo dois labels de destino para cada imagem de dígito: a primeira indica se o dígito é grande ou não (7, 8 ou 9) e a segunda indica se é ou não ímpar. \n",
        "\n",
        "As próximas linhas criam uma instância do `KNeighborsClassifier` (que suporta classificação multilabel, mas nem todos os classificadores suportam) e nós a treinamos usando o array de múltiplos alvos. \n",
        "\n",
        "Agora você pode fazer uma previsão e perceber que ela gera dois rótulos:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QinohtD1R3ZE",
        "colab_type": "code",
        "colab": {},
        "outputId": "00cd58f8-ab67-4855-a6f1-8c0f0b27042f"
      },
      "source": [
        "knn_clf.predict([some_digit])"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[False,  True]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 70
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sI_Ee_U2R3ZF",
        "colab_type": "text"
      },
      "source": [
        "E como podemos ver, o dígito 5 não é de fato grande (False) e ímpar (True). \n",
        "\n",
        "Há muitas maneiras de avaliar um classificador de vários rótulos, e selecionar a métrica correta realmente depende do seu projeto. \n",
        "\n",
        "Por exemplo, uma abordagem é medir a pontuação F1 para cada rótulo individual (ou qualquer outra métrica de classificação binária discutida anteriormente) e, em seguida, simplesmente calcular a pontuação média. \n",
        "\n",
        "Esse código calcula a pontuação média da F1 em todos os rótulos:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XTGtaBkzR3ZF",
        "colab_type": "text"
      },
      "source": [
        "**Atenção**: a seguinte célula pode demorar muito tempo (possivelmente horas dependendo do seu hardware)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "--TQGoFMR3ZG",
        "colab_type": "code",
        "colab": {},
        "outputId": "48b62c69-e85a-4967-d0fe-2c15a7fe3807"
      },
      "source": [
        "y_train_knn_pred = cross_val_predict(knn_clf, X_train, y_multilabel, cv=3, n_jobs=-1)\n",
        "f1_score(y_multilabel, y_train_knn_pred, average=\"macro\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.97709078477525"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 71
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uN9RFWlVR3ZH",
        "colab_type": "text"
      },
      "source": [
        "Isso pressupõe que todos os rótulos são igualmente importantes, o que pode não ser o caso. \n",
        "\n",
        "Em particular, se você tiver mais fotos de Ana do que do Rogerio ou do Carlos, talvez queira dar mais peso à pontuação do classificador nas fotos de Ana. \n",
        "Uma opção simples é dar a cada label um peso igual ao seu suporte (ou seja, o número de instâncias com esse label alvo). \n",
        "\n",
        "Para fazer isso, basta definir `average = \"weighted\"` no código anterior"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "q4e2lm9AR3ZI",
        "colab_type": "text"
      },
      "source": [
        "## Classificação Multioutput"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JXIOTnmeR3ZI",
        "colab_type": "text"
      },
      "source": [
        "O último tipo de tarefa de classificação que vamos discutir aqui é chamado classificação multioutput-multiclass (ou simplesmente classificação multioutput). É simplesmente uma generalização da classificação multilabel, onde cada etiqueta pode ser multiclasse (isto é, pode ter mais de dois valores possíveis).\n",
        "\n",
        "Para ilustrar isso, vamos criar um sistema que remova o ruído das imagens. Ele terá como entrada uma imagem com dígitos ruidosos, e produzirá (se tudo der certo) uma imagem com dígitos limpos, representada como uma matriz de intensidades de pixel, assim como as imagens MNIST. \n",
        "\n",
        "Observe que a saída do classificador é multilabel (um rótulo por pixel) e cada rótulo pode ter vários valores (intervalos de intensidade de pixel de 0 a 255).\n",
        "\n",
        "É, portanto, um exemplo de um sistema de classificação de múltiplas saídas.\n",
        "\n",
        "**NOTA:** A linha entre classificação e regressão é às vezes embaçada, como neste exemplo. Indiscutivelmente, a previsão da intensidade do pixel é mais semelhante à regressão do que à classificação. Além disso, os sistemas de múltiplas saídas não se limitam a tarefas de classificação; Você pode até ter um sistema que produza vários rótulos por instância, incluindo rótulos de classe e rótulos de valor.\n",
        "\n",
        "Vamos começar criando os conjuntos de treinamento e teste pegando as imagens MNIST e adicionando ruído às suas intensidades de pixel usando a função `randint()` do NumPy. As imagens de destino serão as imagens originais:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PdaqCWzeR3ZI",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "noise = np.random.randint(0, 100, (len(X_train), 784))\n",
        "X_train_mod = X_train + noise\n",
        "noise = np.random.randint(0, 100, (len(X_test), 784))\n",
        "X_test_mod = X_test + noise\n",
        "y_train_mod = X_train\n",
        "y_test_mod = X_test"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V9qRa0X8R3ZM",
        "colab_type": "text"
      },
      "source": [
        "Vamos dar uma olhada em uma imagem do conjunto de testes:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RyjKZ5RNR3ZM",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "some_index = 5500\n",
        "plt.subplot(121); plot_digit(X_test_mod[some_index])\n",
        "plt.subplot(122); plot_digit(y_test_mod[some_index])\n",
        "plt.show()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XQY74dgFR3ZP",
        "colab_type": "text"
      },
      "source": [
        "À esquerda está a imagem de entrada ruidosa e à direita está a imagem alvo limpa. Agora vamos treinar o classificador e torná-lo limpo esta imagem:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2gL4__VTR3ZQ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "knn_clf.fit(X_train_mod, y_train_mod)\n",
        "clean_digit = knn_clf.predict([X_test_mod[some_index]])\n",
        "plot_digit(clean_digit)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7rUqWhKbR3ZS",
        "colab_type": "text"
      },
      "source": [
        "Parece perto o suficiente do que queriamos!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Su-MmhcNR3ZT",
        "colab_type": "text"
      },
      "source": [
        "## Classificador Dummy (aleatório)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_939n_OUR3ZT",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from sklearn.dummy import DummyClassifier\n",
        "dmy_clf = DummyClassifier()\n",
        "y_probas_dmy = cross_val_predict(dmy_clf, X_train, y_train_5, cv=3, method=\"predict_proba\")\n",
        "y_scores_dmy = y_probas_dmy[:, 1]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": true,
        "id": "ugZSI5EDR3ZY",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "fprr, tprr, thresholdsr = roc_curve(y_train_5, y_scores_dmy)\n",
        "plot_roc_curve(fprr, tprr)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "T59wFhMiR3ZZ",
        "colab_type": "text"
      },
      "source": [
        "## Classificador KNN "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q1uzbdTkR3ZZ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from sklearn.neighbors import KNeighborsClassifier\n",
        "knn_clf = KNeighborsClassifier(n_jobs=-1, weights='distance', n_neighbors=4)\n",
        "knn_clf.fit(X_train, y_train)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fbr7TJzBR3Zb",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "y_knn_pred = knn_clf.predict(X_test)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6Oew0bPlR3Zc",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from sklearn.metrics import accuracy_score\n",
        "accuracy_score(y_test, y_knn_pred)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "joFXFZT2R3Zc",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from scipy.ndimage.interpolation import shift\n",
        "def shift_digit(digit_array, dx, dy, new=0):\n",
        "    return shift(digit_array.reshape(28, 28), [dy, dx], cval=new).reshape(784)\n",
        "\n",
        "plot_digit(shift_digit(some_digit, 5, 1, new=100))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jmhfjlLAR3Zd",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "X_train_expanded = [X_train]\n",
        "y_train_expanded = [y_train]\n",
        "for dx, dy in ((1, 0), (-1, 0), (0, 1), (0, -1)):\n",
        "    shifted_images = np.apply_along_axis(shift_digit, axis=1, arr=X_train, dx=dx, dy=dy)\n",
        "    X_train_expanded.append(shifted_images)\n",
        "    y_train_expanded.append(y_train)\n",
        "\n",
        "X_train_expanded = np.concatenate(X_train_expanded)\n",
        "y_train_expanded = np.concatenate(y_train_expanded)\n",
        "X_train_expanded.shape, y_train_expanded.shape"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GLFBmU29R3Ze",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "knn_clf.fit(X_train_expanded, y_train_expanded)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "z_ZbWhcOR3Zf",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "y_knn_expanded_pred = knn_clf.predict(X_test)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IOjRnHa2R3Zg",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "accuracy_score(y_test, y_knn_expanded_pred)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w9C5jr1XR3Zg",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "ambiguous_digit = X_test[2589]\n",
        "knn_clf.predict_proba([ambiguous_digit])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3UAk-9nBR3Zh",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "plot_digit(ambiguous_digit)"
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}