classification_mnist.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Scikit-learn\n",
    "#  \n",
    "# Géron (2022)\n",
    "#   Ch. 3 \"Classification\" (pp. 103-174\n",
    "#   Data : MNIST\n",
    "#       Note: the training set is already shuffled for us\n",
    "\n",
    "import pandas as pd\n",
    "\n",
    "# Get the data as NumPy array with as_frame=False\n",
    "from sklearn.datasets import fetch_openml\n",
    "mnist = fetch_openml('mnist_784', \n",
    "                     as_frame=False,\n",
    "                     parser='auto')\n",
    "\n",
    "X, y = mnist.data, mnist.target"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X has 70000 rows and 784 columns\n",
      "y has 70000 rows\n"
     ]
    }
   ],
   "source": [
    "# X has 70000 rows images and 784 columns (28 times 28 pixels), y has 70000 labels\n",
    "print(f\"X has {X.shape[0]} rows and {X.shape[1]} columns\")\n",
    "print(f\"y has {y.shape[0]} rows\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZkAAAGYCAYAAACQ+Z9rAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA3g0lEQVR4nO3deXwUZZ4/8E93ks7BuSTschhEBhSEl4soieS+uFzRYUBAVw5PBAUZwJXMqhxRQRDHkbgwo0BENEJEB30JDGYxJqCS4BJGUBEYCFdQxhESjqTT3fX7g19lcjR0PV1Vj5Xi8/4HIfXp57FTnW+qQ31wKIqigIiIyATOX3oDRERkXxwyRERkGg4ZIiIyDYcMERGZhkOGiIhMwyFDRESm4ZAhIiLTcMgQEZFpQn+JRX0+H06ePIk2bdrA4XD8ElsgIiIdFEVBdXU1unTpAqfz8tcrv8iQOXnyJGJjY3+JpYmIyEDHjh3DNddcc9mP/yJDpk2bNgCAw4cPo0OHDppzdXV12Lp1K4YMGYKwsLCrMmP1/fF5kJux+v74PMjNyFyrqqoKsbGx9V/PL+cXGTLqW2Rt2rRB27ZtNefq6uoQFRWFtm3bCj15dspYfX98HuRmrL4/Pg9yM7LXAhDwRx78wT8REZmGQ4aIiEzDIUNERKbhkCEiItNwyBARkWk4ZIiIyDQcMkREZBqh+2RKS0vxxBNPICwsDF27dsWf/vQnjBgxAgBw4cIF1NXVYffu3aZslIiIWh6hIRMbG4tt27YhMjIS2dnZ+Mtf/oKioiIAQF5eHioqKszYIxERtVBCQ6Zz5871/+1yuRqVohUUFOCll17ym6utrUVtbW3976uqqgBcusu0rq5O8/rqsVdzRuZaVs7IXMvKGZlrWTkjcy0rZ2SupfVYh6IoiuZH/f8qKiowbtw4FBcXIywsDGfOnEFmZia++uorv8fPmzcP8+fPb/bn77zzDqKiokSXJyKiX9iFCxdw77334uzZs1esBxMeMlVVVbjjjjvw+uuv44YbbgAAvPnmm6ioqMCzzz7rN+PvSiY2NhaVlZWIjo7WvHZdXR0++eQTDB48WKiTx04Zq++Pz4PcjNX3x+dBbkbmWlVVVYiJiQk4ZITeLvN4PBg3bhzmzp1bP2CAK79VBgDh4eEIDw9v9udhYWHCZWzB5uyWkbmWlTMy17JyRuZaVs7IXMvKGRlraT1O6K8w5+fnY+fOncjJyUFaWhrWrVuHs2fP4tSpU+jdu7fIQxER0VVA6Epm/PjxGD9+fLM/37Vrl2EbIiIi++DNmEREZBoOGSIiMg2HDBERmYZDhoiITMMhQ0REphEaMqWlpRg0aBBSUlJwzz33oK6uDsePH8edd96J9PR0zJ0716x9EhFRC6SrIHPjxo3YsGEDli9fjq5du5q1RyIiaqF0FWR6vV4cOXIEs2bNwo8//ojnnnsOCQkJzXIsyDQuI3MtK2dkrmXljMy1rJyRuZaVMzLXklKQuX79elx//fXYv38/XC4XRowYgbKysmbHsyCTiMhepBRkduvWDXFxcfj6668BAAkJCSguLkZoaOMLJBZkGpex+v74PMjNWH1/fB7kZmSuJa0gMzo6GmfOnEFYWBhqa2ubDRiABZlmZGSuZeWMzLWsnJG5lpUzMteyckbGWtIKMl944QWMGDECGRkZft8SIyKiq5chBZklJSWGbYiIiOyDN2MSEZFpOGSIiMg0HDJERGQaDhkiIjINhwwREZlGd0Fmr169kJaWhrS0NHzyySdm7ZOIiFog3QWZ7dq1Q1FRkUnbIyKilkxXQabT6cS5c+eQmpqKrl27Ijc3Fx06dGiWY0GmcRmZa1k5I3MtK2dkrmXljMy1rJyRuZaUgszi4mJUVVUhOjoaa9asQVlZGZYtW9bseBZkEhHZi5SCTLW/TF1w2LBhKC4ubpZhQaZxGavvj8+D3IzV98fnQW5G5lpSCjLdbjcURUF4eDhKSkrQs2dPvzkWZBqfkbmWlTMy17JyRuZaVs7IXMvKGRlraT1OaMg0LMjMycnBlClTsHjxYrRq1Qrh4eFYtWqVyMMREZHN6S7IHDt2rKEbIiIi++DNmEREZBoOGSIiMg2HDBERmYZDhoiITMMhQ0REptFdkAlcagAIDw/H3r17TdkkERG1TEJDRi3ILC4uRvfu3bFx40YAwOLFi5GYmGjKBomIqOXSXZB5+PBhOBwOdOvW7bI5FmQal5G5lpUzMteyckbmWlbOyFzLyhmZa0kryJw2bRrmzJmDefPmYfbs2ejXr1+z41mQSURkL1oLMoWuZIBLVyHjx49HXl4ejh49CgDo3r37FTPZ2dmYOXNmo8eIjY1Feno6CzItXIBn5YzV98fnQW7G6vuz4/OgviMViK6CzPfffx/79u3DsGHD8PXXX+PgwYMoLCxEREREoxwLMo3PyFzLyhmZa1k5I3MtK2dkrmXljIy1tB4n9IP/hgWZaWlpqKurQ0lJCbZs2YLBgwdjxYoVzQYMERFdvXQXZKry8vKM2A8REdkIb8YkIiLTcMgQEZFpOGSIiMg0HDJERGQaDhkiIjINhwwREZlGdwvzqFGjkJqaivj4eBQXF5u1TyIiaoGE7pNRW5gjIyORnZ2NjRs3Ij8/Hy6XC0eOHMFDDz2EwsJCs/ZKREQtjO4WZpfLBQCorq72W44JsIXZyIzMtayc0btWbW0tvF6vpozH4wEAnD59GqGh2l4ysjIA8MYbb6Bv375YsmQJfD6fpozT6UTfvn2xYMECocytt96KiRMn1u81kNDQUIwdOxYnTpxASEiIpoz6eZk8ebLmdQDg448/xqpVq9CpUydcvHhRUyYyMhKrVq3Ctddei5qaGk2ZiIgILF++HIsXLxZ67vr162f514UlW5jDwsKQkpKC77//HmvWrMGQIUOaHc8WZiIie9Hawiw8ZKqqqnDHHXfg9ddfxw033FD/50ePHsVdd92F3bt3N8v4u5KJjY1FZWUlW5gt3LJq5YzetTIzM4WuMP73f/8XAwcOFMqUlZWZngH+eSWzb98+4SuZXbt2CV/JrFu3TvhK5t///d+FrmT27NmDjRs3BnUl88ADDwhfyUyZMkX4Smbv3r3CVzJWf12ItjDHxMQYW/XftIVZURR4PB6EhYWhdevWaN26td8cW5iNz8hcy8qZYHOhoaFBZUS++MvKqF/ofD6f5i96DbNa3zZUeTwe4bdwQkJCNA+ZhuuIDBl1sFy8eFHzkFHV1NQIZ4J5vq3+ujCjhVno7G/YwpyTk4P7778fq1evBnDpu48XXnhB5OGIiMjmdLcwT5w40dANERGRffBmTCIiMg2HDBERmYZDhoiITMMhQ0REpuGQISIi0+gqyKyurkZGRgZSUlKQkZGBiooKs/ZJREQtkNCQUQsyi4uL0b17d2zcuBFr165FcXExnnrqKSxZssSsfRIRUQukqyAzKioKXbp0qf+90+l/ZrEg07iMzLXUYysqKoTLDQ8cOCCcyc/P17w3ACgrK0NWVhZmzpyp+a71kJAQZGVl4ZFHHhGqRhk1ahRuvPFGobqSlStXmp5pmHvllVeE1/rjH/8olImLi8N3333X6PV8JWrTR3Z2ttDzfffdd2PTpk1Cz0NMTEz9ryIVMQAQHx8Pt9utKaOWAicmJsLhcGjKKIqC6upqW359CMSQgky3243BgwfjjTfeQK9evZodz4JMIiJ7kVqQOWnSJAwfPhxjx471m2FBpnGZX2J/ffv2Fboq2bdvH3r16iWUOXDgAM6ePavpeJV6JVNYWCh8JbNhwwbhK5kHH3xQ+ErB7IzMtdTMM888I3Qlk5OTg4KCAuErGdHnITo6GsuWLcO0adOErmSWLVuGFStWCF3JPProo2jTpo3wlYydvj5IKcgEgPnz56NHjx6XHTAACzLNyMhcK5hyw2AyotTB4vV6hYoUAfHyRSC44kVZGZlr1dbWav4irgqmVFN0b+qeampqhPfndrs1DxmVw+HQPGRUdvr6oPU4oR/8NyzITEtLw5tvvomcnBxs27YNaWlpyM7OFnk4IiKyORZkEhGRaXgzJhERmYZDhoiITMMhQ0REpuGQISIi03DIEBGRaXQVZNbV1WHChAno2LEjcnNzzdojERG1UEJ/hVktyIyMjER2djY2btyIRYsWISMjA+fOnTNrj0RE1ELpKsh0Op31BZlXwoJM4zLB5srLy+t/vVyRaVM+nw8AkJGRIVTT8corryAxMVG4rmTmzJnCdSpDhw7F+vXrhdYaOnQotm7dKpQZO3YsIiMjhfbW8FezMnrXatWqleZmBrVM8umnnxbaHwCMGTNGOPPWW28JHf+v//qv+Omnn/D+++8LneM//fQTXnnlFaEapL/97W+Ij48Xrm2x6tcHyxdk5uXl4dy5c3j88cf9Hs+CTCIie9FakCl0JQNcugoZP3488vLyNE/x7OxszJw5s9FjxMbGIj09nQWZkgrwysvLcfLkSXTp0kXou7yTJ09ixowZwlcydiyGtGJG71oPP/yw0Of29ddfr38nQqu2bdtqLjBVhYSECGfUK5no6GjhK5kePXoIX8nY6etDsAWZWuguyNSCBZnGZ0Rz6ovO6XRqfgGqgikctGMxpJUzweZqamqCWsuK9JzjwRS62unrQzAZrccJDZmGBZk5OTmYMmUKysvL8eGHH8Lr9eLQoUP4/e9/L/KQRERkY7oLMseOHYuFCxcauikiIrIH3oxJRESm4ZAhIiLTcMgQEZFpOGSIiMg0HDJERGQa3QWZBQUFSEhIQGZmJo4fP27WPomIqAUSGjJqQWZxcTG6d++OjRs34uWXX0ZRUREWLFiAnJwcs/ZJREQtkK6CzP3796NPnz5wuVxITEzE7Nmz/eZYkGlcJticWnap/iqSUYsRtVCPtXoxpF0yetcK5nNrVXrOcZEKG/VYO319sGxB5qJFi/DBBx/glVdeAQDExcWhtLS02fEsyCQishcpBZler7dRSdrlun9YkGlcJtjc6dOnUVZWhoEDByI0VNun3ePxoKysDAsWLGh0JXol4eHhePbZZy1fDCkrk5ubC7fbrSnjcrnw+OOP46233hL6jrKsrAzLly/HlClThMouly9fjunTpwtlXn31VVu9LuyWkbmWlILMuro6fPvtt3C73di1axduuukmvzkWZBqfEc2pgyU0NFTzkFE1fbtTC6sXQ8rKuN1uzUNGJfo2sjokgim7DKb81E6vC7tmZKwlrSBzxowZSEtLQ0REBN58802RhyMiIpvTXZAJXCrJJCIiaoo3YxIRkWk4ZIiIyDQcMkREZBoOGSIiMg2HDBERmUZoyJw9exZxcXFo3bo19u7dCwBYunQpEhMTMXToUFRWVpqySSIiapmEhkxUVBQ+/vhjjB49GgBw6tQpfPzxx9i+fXv9vTNEREQqoftkwsLC0LFjx/rfV1RUoG/fvnA4HBgwYAAefPBBvzkWZBqXCTbn8Xga/SqS8dfWcDnqsVYvhpSVcblcmjPqsaJ3aavFlcGUXQaTsdPrwm4ZmWuZWpA5adIkzJ49G506dcKIESNQVFSETz/9FA8++CBOnDjR7HgWZBIR2YtpBZkNxcTEYMqUKRgyZAj69++P3r17+z2OBZnGZX6J/Yl+H+JwOLB161bNV02hoaEYMmQITpw4IbTW3LlzpZZdLl26VKjsctasWUhKShIqJN2+fbvw+bBv3z5UVFTg2muvhdOp7R1wn8+HiooKFBYWaq65DwkJQVZWFl8XFs7IXMuUgkx/JkyYgAkTJqCoqAgxMTF+j2FBpvEZ2WuJ8ng8Qm/NAYCiKEJDRh0SVi67DKaQVPRzpA4Wp9OpeciovF6v8OeJrwvrZ2SsZUpBJgDcfvvtKC8vx/79+zF58mRs2bIFP/74I6699lq89tprog9HREQ2JjxkNm3a1Oj3kyZNMmovRERkM7wZk4iITMMhQ0REpuGQISIi03DIEBGRaThkiIjINBwyRERkGt0tzK+99hri4uIQFxeHDRs2mLJJIiJqmYTuk1FbmJ988sn6P/uf//kf7NmzB263G8nJyRg1apThmyQiopZJVwszAPTo0QMXL17EhQsX0L59e785tjAbl5G5lnrskCFDhDuQcnJyhDq7vvjiC0yaNEmoBmP//v0AgAceeECofwsIrlF5+vTpmjMqkZoOh8MBQPx86NmzJw4fPoyePXsKfZ4OHz6Ml156Sfhzy9eFdTMy15LSwtyvXz+sWLECzz33HLxeL1auXInbb7+92fFsYSYishetLcy6hky3bt2QnJyML7/8Em63GxkZGdi1a1f9d2Qqf1cysbGxqKysZAuzhVtW9WQGDRokfCWTlZUl9DzMmjULWVlZQTUJB9PCfP78ec17A4BWrVrxfODrQmpG5lpVVVWIiYkxt+rf6XQiMjISERERCAsLg9vthqIozYYMW5iNz8hcK5iMjPZhdbAE0yQcTAtzMHg+yM3IXMvKGRlrSWth/s1vfoNBgwbB5/PhscceE64aJyIi+9LdwgwA//Vf/2XIZoiIyF542UFERKbhkCEiItNwyBARkWk4ZIiIyDQcMkREZBqhv1129uxZDB48GN988w2+/PJL/OpXv8Lw4cMBXLr7s66uDrt37zZlo0RE1PLoKsiMjIxEUVERACAvLw8VFRWGb5CIiFou3QWZqoKCArz00kt+P8aCTOMyMtfSk1FbIEQyHo+nWVvElfzLv/xL/a8yCjLz8/M1PxdhYWF46KGH4Ha74fP5NGXU1gI7ng98Xdj3eQhEd0EmAJw5cwaZmZn46quv/B7PgkwiInvRWpCpq7tMtXHjRtx1112X/Xh2djZmzpxZ/3u1IDM9PZ0FmRYuwLNyBrj0zUtcXBxKS0uFrmTi4uKCKsh84403hK9ksrKyhIpCCwsLeT7wdRF0RuZa6jtSgRgyZK70VhnAgkwzMjLXsmqmYUGm1iGjCqYgs66uDm63WygTGhrK80FiRuZaVs7IWEtaQebIkSNx6tQp9O7dW/ShiIjI5gwpyNy1a5chmyEiInvhzZhERGQaDhkiIjINhwwREZmGQ4aIiEzDIUNERKYRGjJnz55FXFwcWrdujb179wIAjh8/jjvvvBPp6emYO3euKZskIqKWSVdBJgA8+eSTWL58Obp27Wr45oiIqGXTVZBZV1eHI0eOYNasWfjxxx/x3HPPISEhoVmOBZnGZWSuZeUM8M+yS/VXkUwwBZkid0+rx6qll1qwIDP4jMy1rJyRuZaUgszo6Gj06NED+/fvh8vlwogRI1BWVtbseBZkEhHZi5SCzPbt26Nnz57o1q0bgEvfvXk8nmaFgCzINC5j9f3JfB6qqqqwfft2JCUlCZVQbt++Paiyy2BKNcPDwzX/8wWKoqC2tpbnA18XQWdkriWlIDMyMhLR0dE4c+YMwsLCUFtb6/fFzoJM4zMy17JqRj3XQkNDNQ8ZVTBll8GUajocDqF/Iwfg+aAnI3MtK2dkrCWtIPOFF17AiBEj4Ha7/b4lRkREVy9DCjJLSkoM2QwREdkLb8YkIiLTcMgQEZFpOGSIiMg0HDJERGQaDhkiIjKN7oLMXr16IS0tDWlpafjkk09M2SQREbVMugsy27Vrh6KiIqP3RURENqCrIBMAzp07h9TUVHTt2hW5ubno0KFDsxwLMo3LyFzLyhngn4WSwZRQBlN2GUyppkg1oHoszwe+LoLNyFxLSkFmv3798NNPPyE6Ohpr1qxBWVkZli1b1ux4FmQSEdmL1oJM3UOm4YLDhg1DcXFxs+P9XcnExsaisrKSBZkWLsCzckbvWtdff73mfyLA6/Xi+++/x/Tp01FTU6MpExERgVdffRXPPPNMo3P/SsLDw5GTk4PNmzcLXZ0NGDAAXbt2xYkTJzRfOTkcDnTt2hVZWVlCz11hYaEtzwe7ZGSuVVVVhZiYGHNbmN1uNxRFQXh4OEpKStCzZ0+/x7Eg0/iMzLWsnAk2FxISIvTv0ABATU2N5iGjqq2tFc54PB6hIaMOFkVRhN6eA6z9ueXrIviMjLWkFGT++te/xvr169GqVSuEh4dj1apVog9HREQ2prsg86mnnjJsM0REZC+8GZOIiEzDIUNERKbhkCEiItNwyBARkWk4ZIiIyDS6CzIBoKKiAuHh4Y3+jIiISGjIqAWZo0ePbvTnixcvRmJioqEbIyKilk93Qebhw4fhcDjQrVu3y+ZYkGlcRuZaVs7oXcvr9WrOqMdGRERozqjH+mu6uBz12NBQsdvXHA5Ho19FMlb83PJ1EXxG5lrSCjIfffRRzJkzB/PmzWvWZ6ZiQSYRkb1oLcjU1V126NAhAED37t2veFx2djZmzpxZ/3u1IDM9PZ0FmRYuwLNy5pfYn8/n07w3AHA6nXjiiSeESjX/8Ic/4MEHH8TFixc1rxMZGYmVK1cK5dTMwYMHNf9/OZ1O9OzZE/379xcqFy0vL7fl+WDFjMy11HekAtE1ZPbs2YN9+/Zh2LBh+Prrr3Hw4EEUFhY2e1uBBZnGZ2SuZeWM7LVEBVOqefHiRaEhoyfn8/mEh2cw5aJ2PB+snJGxlpSCzMmTJ6OkpATAP99CE3nfmoiI7E13QaYqLy9P716IiMhmeDMmERGZhkOGiIhMwyFDRESm4ZAhIiLTcMgQEZFpOGSIiMg0uluYR40ahdTUVMTHx6O4uNiUTRIRUcskdJ+M2sL85JNP1v9Zfn4+XC4Xjhw5goceegiFhYWGb5KIiFom3S3MLpcLAFBdXe23HBNgC7ORGZlrWTkjcy312KFDhwp3QW3evBlOp7Y3DHw+H44ePYrBgwcL7W/nzp0ALvWRaaUe++KLLwr3nb300kuaW6xDQkKQnp6O48ePC/WdAdY/H6yYkbmWtBZmAEhJScH333+PNWvWYMiQIc2OZwszEZG9aG1hNmTIAMDRo0dx1113Yffu3c2O93clExsbi8rKSrYwW7hl1coZq+9PzXTr1k34Smb16tXCVzLBtjAHk/n000+Fr2RuuukmoSuZv/71r7Y8H+z0uqiqqkJMTIy5Vf+KosDj8SAsLAytW7dG69at/R7HFmbjMzLXsnJG5lrBZJxOp+YhoxJ9G1kdEsG0MAeT8Xq9Qv/oGyCvuTnYnN0yMtaS0sI8ceJEvPvuuwAunXgvvPCC6MMREZGN6W5hfvTRRw3bDBER2QtvxiQiItNwyBARkWk4ZIiIyDQcMkREZBoOGSIiMo2ugszq6mpkZGQgJSUFGRkZqKioMGufRETUAgkNGbUgc/To0QAu3Yyzdu1aFBcX46mnnsKSJUtM2SQREbVMugoyIyIi0KVLFwCXijIvd2czCzKNy8hcy8oZmWvpyfTq1Uuo2uPIkSNYuXIlQkO1vzQ3b94MAFixYoXmjCoqKgoOh0PTsWqpZn5+vlAVTVZWFqZNm6b5+QsLC8MDDzxgy/PBjq+LQAzpLnO73Rg8eDDeeOMN9OrVq9nxLMgkIrIXrQWZurrLVI888gimTp3qd8AAQHZ2NmbOnFn/e7UgMz09nQWZFi7As3LG6vvTk4mPjxe+kmnbtm39OwRatW3bFg899JDQVckbb7wRVKnmqlWrhK9keD5Y+3Wh9XzTPWTmz5+PHj16YOzYsZc9hgWZxmdkrmXljMy1ZGVCQ0OFhowesko1Rd8aB3g+6MnIWEtKQebtt9+OnJwcJCUlYdu2bRg0aBAWLlwo+pBERGRTugsyn3nmGcM2Q0RE9sKbMYmIyDQcMkREZBoOGSIiMg2HDBERmYZDhoiITKOrIBMAJkyYgI4dOyI3N9eUDRIRUcsl9FeY1YLMJ598sv7PFi1ahIyMDJw7d87wzRERUcumqyATQH1B5pWwINO4jMy1rJyRuZbsjMfj0ZzRSy29FDk2mIzInefqsTwfWsbrIhBDCjLz8vJw7tw5PP74436PZ0EmEZG9SC3IDIQFmcZlrL4/Pg9yM3rXmjx5MmpqajRlIiIi8Mc//jGogsxg1mnTpo3mf4YAAOLj4y37eWop54MlCzK1YEGm8RmZa1k5I3MtK2eCzdXU1EgpyAxmHYfDITRk1P93K3+erH4+WK4gc/Lkydi/fz8+/PBDeL1eHDp0CL///e9FH5KIiGxKd0EmADYvExGRX7wZk4iITMMhQ0REpuGQISIi03DIEBGRaThkiIjINLoLMgsKCpCQkIDMzEwcP37clE0SEVHLJDRk1ILM0aNHA7jUsfTyyy+jqKgICxYsQE5OjimbJCKilklXQeaBAwfQp08fuFwuJCYmYvbs2X5zLMg0LiNzLStnZK5l5YzetSIiIjRn1GODKcgMZh3RWkUrf55ayvlguYLMqqoqrF+/Hq+88goAIC4uDqWlpc2OZ0EmEZG9SCnIbN++faOStJCQEL/HsSDTuIzV98fnoXEmNjYWTqe2d6V9Ph+OHTuGPXv2wOfzacoAwNdff40JEyZgzZo1mr+7DAsLw4QJE4Iquwwms3TpUrjdbk0Zl8uFWbNmISsrC6Gh2r9Eeb1ey58PdnpdSCnI7NWrF7799lu43W7s2rULN910k9/jWJBpfEbmWlbOyFwrmIzT6dQ8ZFQ+n09oyDR8q0P0rZVgyi6Dybjd7kZvmWsRGhoq9Hyrz7OVzwc7vS6kFWTOmDEDaWlpiIiIwJtvvin6cEREZGOGFGSOHTvWkM0QEZG98GZMIiIyDYcMERGZhkOGiIhMwyFDRESm4ZAhIiLT6B4yXq8X9913H9LT0/HAAw/A4/EYsS8iIrIB3UPmgw8+wHXXXYdPP/0UvXv3xvvvv2/EvoiIyAZ03fEPAIcOHUL//v0BAAMGDMCf//xnjBkzptExLMg0LiNzLStnZK6lJyNy5756rGhDgHrntcjd3eqxwZRdBpNxuVyaM+qxou+KeL1eANY+H+z4uggkqILMhj766CNs2bIFr732GubMmYNjx47h7bffbnQMCzKJiOxFa0Gm7iGjKApmz56N3bt3o2/fvnC5XFi6dGmjY/xdycTGxqKyspIFmRYuwLNyRu9aPXr0uGyha1Nerxd/+9vf8Nlnn9V/txxISEgIUlNTMWfOHM2dXeHh4Vi0aJFQASWgr7gymMwjjzyCmpoaTZmIiAj86U9/wltvvSVU3jl+/Hi+Liz+9aGqqgoxMTHmtjADgMPhqB8q8+bNQ0ZGRrNjWJBpfEbmWlbOBJsLCQnRPGRUXq9X85BR1dbWav6CrAqmgDLYXDCZmpoa4Uww5Z18XQSfkbGW1uN0/+D/1KlTSE9PR2ZmJlwuF1JSUvQ+JBER2YTuK5lOnTrh008/NWIvRERkM7wZk4iITMMhQ0REpuGQISIi03DIEBGRaThkiIjINBwyRERkGt1DxufzYdKkSUhOTkZSUhK+++47I/ZFREQ2oHvIlJeXo7a2FiUlJVi4cCFefvllI/ZFREQ2oPtmzGuuuQaKokBRFPz888+IiYlpdgxbmI3LyFxLdubkyZNCVS/vvfcerrvuOrz22mvQWsHncDhw3XXX4d577xXqFJs/fz7efvttoZ6vjIwMVFVVac643e76rAg97ci33XZb/bqBqO3Ia9asEdofAOTn5wv3aPF10TK+PgSiuyDT5/Nh4sSJKC0tRU1NDXbs2IFrrrmm0TFsYSYishdpLcxbtmzBunXrsHr1auzatQtLlizBunXrGh3DFmbjMlbfn55M//79g7qSOXz4sPCVzNy5c4WvZGS1HMtsYX711VeFrmSmT5+ueV8N8XVhv68P0lqYFUWpHxTqgk2xhdn4jMy1ZGVCQkIQGqr9lFQHi/p2rYim3/hoIavlWGYLs9vt1jxkGnI4HJqOUz8vfF3IzchYS+txuofM4MGDkZeXh9TUVNTW1vIH/0REVE/3kAkNDW329hgRERHAmzGJiMhEHDJERGQaDhkiIjINhwwREZmGQ4aIiEyje8h88cUXSEtLQ1paGq6//nr89re/NWJfRERkA7r/CvOgQYNQVFQEAJg0aRJ+/etf631IIiKyCd1DRuV2u1FaWopVq1Y1+xgLMo3LyFxLPbayslJz3YvX6wUAfPbZZ8J3hY8ePVroLvxjx45h5cqVeP7554XrVE6fPi2Uafir2ZmEhAShu/BnzJgBAFi7dq3mjGrLli2aWxY8Hg8KCwuDqiux4+vCihmZa0kryFRt2rQJmzdvxrJly5p9jAWZRET2Iq0gU3X//ffj/vvvR0pKSrOPsSDTuMwvsb+bb75Z6Epm9+7daNWqldCVzPnz57Fw4cKgrmSsWFypJ5Obmyt8JeN0OuHz+TRnAMDpdCIrK0vKlYwdXxdWzMhcS1pBprrBsrIyrFy50u/HWZBpfEbmWqLFlcClAkWtQ0YlWlqpfvG2cnGlzNLKYISGhlr2HLf668LKGRlraT3OkL/CXFhYiIyMDDid/BvRRET0T4ZcyQwfPhzDhw834qGIiMhGeOlBRESm4ZAhIiLTcMgQEZFpOGSIiMg0HDJERGQaQ4ZMUVERMjMzkZ6ejg8++MCIhyQiIhvQ/VeYL168iKVLl2Lz5s1wuVxG7ImIiGxC95D54osvEBkZiREjRiAqKgrLly9Hp06dGh3DgkzjMjLXUo9VSy+1UI8VaStSj/XXCnElsosrZWVkfrPm8XiEj+XrwroZmWtJK8jMz8/HkiVL8OWXX6KwsBAffvghVqxY0egYFmQSEdmLtILMzZs3Y9OmTVi2bBlqa2uRlZWFkpKSRsewINO4DACcPn0aZWVlGDhwoOZOsdmzZ2PUqFHYsGGD5u9eQ0NDMWrUKCxYsEBzp1h4eDieffZZ08skg83pyaxYsUJzp5jL5cKjjz4qdEUHXOp8S0lJEeqKCwkJsez5asdiSCtnZK4lrSBz4MCBWLp0KRRFQXl5OXr06NHsGBZkGptRvwCFhoYKNeiqv4pefosWVwLyyiRlriWruFLk86oeD1j3fJWZkbmWlTMy1tJ6nO4hExMTg5EjRyI1NRUOh8PvP1pGRERXJ0MKMh977DE89thjRjwUERHZCG/GJCIi03DIEBGRaThkiIjINBwyRERkGg4ZIiIyje4hc+TIEXTs2BFpaWlIS0vD6dOnjdgXERHZgCF/hTk1NRXvvfeeEQ9FREQ2YsiQ2bFjB5KTk5GcnIznn38eDoej0cdZkGlcBmh8975WDVsCRDMixZXqsWaXSQabk1VcqafkUuTzCvyzYNSK56udiyGtmJG5lrSCzNraWng8HkRFReHhhx/G8OHDMWrUqEbHsCCTiMhepBVkNrRp0yZ8+eWXWLBgQaM/v5oKMmNiYuB0avtRl8/nw9///ncUFBQIffe6b98+PPfcc3j66ac1d4r94x//kFomKaMgs0OHDsjNzcXjjz+OmpoaTZmIiAjk5ubi//7v/+Dz+TRlnE4nBgwYgKSkJKGuuO3bt9uqENHKGavvz47Pg7SCzOrqarRp0wYAUFJSgj59+jQ75moqyHQ6nZqHjEq0tFIdLLW1tZq/uKpfvGWVScrIqP/vNTU1wmv5fD6hfycHEC+uBOxViNgSMjLXsnJGxlpaj9P9t8u2b9+OW265BcnJyThx4gTuvfdevQ9JREQ2oftKZvjw4Rg+fLgReyEiIpvhzZhERGQaDhkiIjINhwwREZmGQ4aIiEzDIUNERKYxbMjk5+ejY8eORj0cERHZgCFDxuv1oqCgALGxsUY8HBER2YQhBZn5+fm4++67sXTpUr8fv5oKMrVWlTQ8VvQucrU9QaS4UnaZpIyCzIiIiEa/imREWhnUY0Wqf9Rj7ViIaMWMzLWsnJG5lrSCTK/Xi5EjR+LPf/4z4uLisGvXrmbHsCCTiMhepBVkvvnmmwgJCcF9992HW2+91e+QuZoKMnft2iVUvHjrrbcKF0PKLq5ctGgR3G63pozL5cKcOXPw1VdfCT0Pt9xyC3bv3i10JTh16lTs3LkT8fHxQsWVO3futPQ5ZNVCRCtnrL4/Oz4P0goyv/nmG+zevRtr167FgQMHMH36dLz66quNjrmaCjKDKV4Mpkwy2FwwGbfbrbntWRXM8+Dz+YSGTMN/I8eqxZV2KkRsCRmZa1k5I2MtrcfpHjIvvvhi/X/feuutzQYMERFdvQy9T8bfW2VERHT14s2YRERkGg4ZIiIyDYcMERGZhkOGiIhMwyFDRESm4ZAhIiLT6L5P5ocffsDIkSMRFhaGkJAQvP322+jcubMReyMiohZO95VMTEwMtm/fjs8++wwTJkzAypUrjdgXERHZgO4rmZCQkPr/rq6uRt++fZsdczW1MP/3f/+3cF/Q6dOng+omEsnpyZSUlAhnfve73wln5syZI/w8AEBUVJTQWg1/bekZmWtZOSNzLStnZK4lrYUZAMrLyzF58mScOXMGW7duxbXXXtvo42xhJiKyF2ktzA2tX78e27Ztw4oVKxr9+dXUwmynllUrZ6y+Pz4PcjNW358dnwdpLcxutxsulwsA0K5dO79XJldTC7OdWlZbQkbmWlbOyFzLyhmZa1k5I2MtaS3M5eXlmD17NkJCQhAREYFVq1bpfUgiIrIJ3UMmLi4OxcXFRuyFiIhshjdjEhGRaThkiIjINBwyRERkGg4ZIiIyDYcMERGZRveQKS0txaBBg5CSkoJ77rlHuAKBiIjsS/eQiY2NxbZt21BcXIzu3btj48aNRuyLiIhsQPd9Mg1r/V0uF5zO5nPrairItGMBnhUzMteyckbmWlbOyFzLyhmZa0ktyASAiooKjBs3DsXFxc3qBliQSURkL1ILMquqqnDHHXfg9ddfxw033NDs4yzINC5j9f3xeZCbsfr++DzIzchcS1pBpsfjwbhx4zB37ly/AwZgQaYZGZlrWTkjcy0rZ2SuZeWMzLWsnJGxltbjdP/gPz8/Hzt37kROTg7S0tKwbt06vQ9JREQ2oftKZvz48Rg/frwReyEiIpvhzZhERGQaDhkiIjINhwwREZmGQ4aIiEzDIUNERKbRPWTOnj2LuLg4tG7dGnv37jViT0REZBO6h0xUVBQ+/vhjjB492oj9EBGRjei+TyYsLAwdO3a84jEsyDQuI3MtK2dkrmXljMy1rJyRuZaVMzLXkl6QOWnSJMyePRv9+vVr9jEWZBIR2YvWgkzdVzJaZGdnY+bMmfW/Vwsy09PTWZBp4QI8K2esvj8+D3IzVt+fHZ8H9R2pQKQMGRZkGp+RuZaVMzLXsnJG5lpWzshcy8oZGWtJK8gEgNtvvx1bt27Fww8/jLy8PCMekoiIbMCQK5lNmzYZ8TBERGQzvBmTiIhMwyFDRESm4ZAhIiLTcMgQEZFpOGSIiMg0hgyZp556CsnJyRg/frxwBQIREdmX7iGzZ88enDhxAiUlJejduzfee+89I/ZFREQ2oPs+mc8//xxDhgwBAAwbNgyrV6/GPffc0+iYpgWZZ8+eBQD84x//EFqrrq4OFy5cwE8//SRUl2CnjNX3x+dBbsbq++PzIDcjc63q6moAQKD6S91D5ueff0bnzp0BAO3atfM7OBYuXOi3IPP666/XuzwREf2Cqqur0a5du8t+XPeQad++fX1R2tmzZ9GhQ4dmxzQtyDxz5gyuvfZaHD169Iqba0ot1jx27NgVWz/tnLH6/vg8yM1YfX98HuRmZK6lKAqqq6vRpUuXKx6ne8gkJCTg5ZdfxoQJE/CXv/wFiYmJzY65XEFmu3bthJ48Vdu2bYVzdsvIXMvKGZlrWTkjcy0rZ2SuZeWMrLW0XCTo/sF///798W//9m9ITk7Gvn37MGrUKL0PSURENmFIQeaSJUuMeBgiIrKZX+RmzPDwcMydO9fvW2hG5+yWsfr++DzIzVh9f3we5GZkr6WFYf/8MhERUVOslSEiItNwyBARkWk4ZIiIyDS/yJAJplDz7NmziIuLQ+vWrbF3715NmdLSUgwaNAgpKSm45557NK31ww8/ICEhAampqcjIyEBlZaWmtQAgPz8fHTt21HTskSNH0LFjR6SlpSEtLQ2nT5/WlCsqKkJmZibS09PxwQcfaMp88cUX9etcf/31+O1vfxsw4/P5MGnSJCQnJyMpKQnfffddwIzX68V9992H9PR0PPDAA/B4PJc91t/ns6CgAAkJCcjMzMTx48c1ZSZMmICOHTsiNzdX0zrV1dXIyMhASkoKMjIyUFFRoXl/o0aNQmpqKuLj41FcXKwpAwAVFRUIDw/3e976y/Tq1av+8/XJJ59oyhw/fhx33nkn0tPTMXfu3ICZixcv1q8RFxeHm2++WfPz8NprryEuLg5xcXHYsGGDpszSpUuRmJiIoUOH+n1N+XutBjof/GUCnQ9NM1rOB3/rBDoXLpcDrnw++MsEOh/8ZQKdD/6eBy3nQ1AUycrLy5X//M//VBRFUZ577jnlnXfe0ZRzu93Kjz/+qEycOFH5+uuvNWVOnjypXLhwQVEURZkzZ45SUFAQMOPxeBSv16soiqKsXr1aycnJ0bSWx+NRRo4cqdx8882ajj98+LAyatQoTceqLly4oNxxxx1KbW2tUK6hiRMnKkVFRQGP++qrr5Rx48YpiqIoxcXFysMPPxwwU1BQoDz99NOKoijKiy++qKxbt+6yxzb9fNbV1Sm33XabUltbq2zfvl155JFHAmYURVFOnDihrF69Wlm2bJmmdS5evKicOHFCURRF2bJli/LYY49pyimKUv+8Hz58WMnMzNSUURRFmTp1qpKenu73vPWXueWWWy77vF0uM27cOOX48eNCGdXq1auVefPmac7deOONSl1dnXL+/HllwIABATOVlZVKenq64vP5lJ07dypTpkxplvH3Wg10PvjLBDofmmbeeuutgOeDv3UCnQuXyynKlc8Hf5lA54O/TKDz4UpfG690PgRD+pVM00LNHTt2aMqFhYVpvkpQde7cGZGRkQAAl8sFpzPw/25ISEj9cdXV1ejbt6+mtfLz83H33XdrWkO1Y8cOJCcn43e/+13Akjng0hVJZGQkRowYgZEjR+LUqVOa1wIAt9uN0tJSJCcnBzz2mmuugaIoUBQFP//8M2JiYgJmDh06hP79+wMABgwYcNnv8IDmn88DBw6gT58+cLlcSExMxF//+teAGQABKy2aZiIiIuozVzon/K3lcrkAXDov+vXrpylz+PBhOBwOdOvWTfM6586dQ2pqKu69916/XYBNM3V1dThy5AhmzZqFjIwMfP7555rWURUUFGDMmDGa99ejRw9cvHgR1dXVaN++fcBMRUUF+vbtC4fDgQEDBqCkpKRZpulrdf/+/QHPB3+v70DnQ9NMVFRUwPPB3zqBzoXL5QKdD/4ygc6Hphmv1xvwfLjS18YrnQ/BkD5kfv755/ragssVahqtoqICW7duxYgRIzQdX15ejvj4eOTm5mLAgAEBj/d6vVi/fj3Gjh2reU+dO3fGwYMHUVxcjB9//BHvv/9+wMwPP/yAgwcP4qOPPsLDDz+MefPmaV4PAAoLC5GZmalpEMbExCAsLAy9e/fGtGnTMHXq1ICZG2+8Edu2batf6+eff9a8t4bnBXDpOTWT2+3GvHnzMG3aNKFcSkoKBg8ejNtvv13T8S+++CJmz54ttMaOHTvw2WefYdiwYX7f6mjq73//O8rLy7F48WK88847eOKJJzSvdebMGZw6dQp9+vTRnPmP//gP9OnTB/3798esWbMCHv+rX/0Ku3btQm1tLQoLC6/4mldfq0lJSZrPB9HXt7+MlvOhaUbrudAwp/V8aJjRej6omYSEBM3nQ9P/p2DOh0CkDxkthZpGqqqqwvjx45GXl6e5wrp///7YuXMncnJysHDhwoDHr127FmPGjBG6igkPD0erVq3gcDjwm9/8Bnv27AmYad++PRITE+FyuZCZmYl9+/ZpXg+49B3K3XffrenYrVu3IjQ0FPv378eGDRs0fTG54447EBERgYyMDJw/fx6dOnXSvLeG5wVw6YrSTI888gimTp2KXr16CeWKi4tRWlqKp556KuCxhw4dAgB0795daI3o6GgAwOjRozWfFz179kS3bt3QqVMnhIWFXfHnYQ1t3LgRd911l+a9VVVVYfny5Thw4AC+++47PPPMMwGvwmNiYjBlyhQMGTIEmzdvRu/evS/72OprtWPHjprOh2Be3/4ygc4Hfxkt50LD3NGjRwEEPh+arqXlfGiYiYmJ0XQ++Pt/Ej0ftJA+ZBISElBYWAgAly3UNIrH48G4ceMwd+5c3HDDDZoybre7/r/btWuHqKiogJlvvvkGa9aswbBhw3DgwAFMnz49YEb9txgAoKSkBD179gyYGThwIL799lsoioLy8nL06NEjYEZVV1eHsrIyJCUlaTpeUZT6kzsmJqb+3wC6EofDgaVLl2Lbtm2Ijo4WOll79eqFb7/9Fm63G59//jluuukmzVlR8+fPR48ePYSuPBVFqf/BbevWrdG6deuAmT179mDfvn0YNmwYPvnkEzz66KOoqam5Ysbtdtf/20taz4vIyEhER0fjzJkzOH/+PGpraxEaqq0xSvStEafTicjISERERKBVq1Zwu92a3uqdMGECPvvsM4wcORJpaWnNPt70tarlfAjm9e0vE+h8aJrRei40zWk5H5pmtJwPTTNazofLPXdGv1UGQP4P/hVFUWbPnq0kJSUp9957r9APsYcPH6507txZue2225TVq1cHPH7NmjVKhw4dlNTUVCU1NVV59913A2Z27typJCcnK2lpacqwYcOUkydPat6fogT+oa1q06ZNyoABA5SkpCRl/PjxSl1dnaZcbm6ukpycrKSkpCgHDx7UvK9NmzYp06ZN03x8XV2dMmbMGCUlJUWJj49XduzYETBTWVmppKWlKRkZGcrzzz8f8Pimn893331XGTRokJKenq4cPXpUU2bOnDnKjTfeqNxwww3KjBkzAmYWLFighISE1J8Tc+bM0bS/5cuX12eSkpKU4uJiTftTXekvrDTMLFq0SBkwYICSnJysZGVlaX4eduzYoSQlJSlxcXHKRx99pClz5swZTedr09yLL76oxMfHKwMHDlSWL1+uKTN27FglPT1dmTRpknL+/Plmx/t7rQY6H/xlAp0PTTN5eXkBzwd/GS3nwpW+/lzufPCXCXQ++MsEOh/8ZbSeD6JYK0NERKbhzZhERGQaDhkiIjINhwwREZmGQ4aIiEzDIUNERKbhkCEiItNwyBARkWk4ZIiIyDQcMkREZBoOGSIiMg2HDBERmeb/AdMLAJY7Lt9KAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "'5'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def plot_digit(image_data):\n",
    "    image = image_data.reshape(28, 28)\n",
    "    plt.imshow(image, cmap=\"binary\", extent=[0, 28, 0, 28])\n",
    "    plt.grid(True, which='both', axis='both')\n",
    "    plt.xticks(range(0, 28, 1), fontsize=6)\n",
    "    plt.yticks(range(0, 28, 1), fontsize=6)\n",
    "    plt.show()\n",
    "\n",
    "plot_digit(X[0])\n",
    "y[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Training data (obs. 0 to 59999) is already shuffled\n",
    "# Test data (obs. 60000 to 69999) does not need to be shuffled\n",
    "X_train, X_test, y_train, y_test = X[:60000], X[60000:], y[:60000], y[60000:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 True\n",
      "0 False\n",
      "4 False\n",
      "1 False\n",
      "9 False\n"
     ]
    }
   ],
   "source": [
    "# We consider two classes: 5 and not-5\n",
    "#   y_train includes numbers in {0,...,9}, convert y_train and y_test to boolean arrays\n",
    "y_train_5 = (y_train == '5')\n",
    "y_test_5 = (y_test == '5')\n",
    "for j1, j2 in zip(y_train[:5], y_train_5[:5]):\n",
    "    print(j1, j2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Training\n",
    "#   Stochastic Gradient Descent (SGD) classifier\n",
    "from sklearn.linear_model import SGDClassifier\n",
    "model = SGDClassifier(random_state = 42)\n",
    "model.fit(X_train, y_train_5)\n",
    "\n",
    "# Predict the image of '5'\n",
    "model.predict([X_train[0]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.95035, 0.96035, 0.9604 ])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Performance measures\n",
    "#   Cross-validation with three folds (cv = 3), two for training, one for validation.\n",
    "#       Note: Géron does not use Cross-validation on the entire data. Therefore, the\n",
    "#             training set is split into three subsets. On page 108, Géron implements\n",
    "#             Cross-Validation manually.\n",
    "from sklearn.model_selection import cross_val_score\n",
    "cross_val_score(model, X_train, y_train_5, cv = 3, scoring = 'accuracy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9522666666666667\n"
     ]
    }
   ],
   "source": [
    "# Overall, 95.23 % of 5s are correctly classified\n",
    "print((y_train_5 == model.predict(X_train)).mean())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.09035\n",
      "0.0\n",
      "1         0         \n",
      "0         0         \n",
      "0         0         \n",
      "0         0         \n",
      "0         0         \n",
      "False\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0.90965, 0.90965, 0.90965])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Dummy classifier.\n",
    "#   'prior': the predict method returns the most frequent class label in y_train_5: non-'5'.\n",
    "#  \n",
    "from sklearn.dummy import DummyClassifier\n",
    "model = DummyClassifier(strategy='prior')\n",
    "model.fit(X_train, y_train_5)\n",
    "prediction = model.predict(X_train)\n",
    "\n",
    "# The training data has 90.965 % of non-'5', the classifier predicts 0% of '5'\n",
    "print(y_train_5.mean())\n",
    "print(prediction.mean())\n",
    "\n",
    "for j1, j2 in zip(y_train_5[:5], prediction[:5]):\n",
    "    print(f\"{j1:<10}{j2:<10}\")\n",
    "print(any(prediction))\n",
    "cross_val_score(model, X_train, y_train_5, cv = 3, scoring = 'accuracy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Precision and recall\n",
    "#   Precision = TP / (TP + FP)\n",
    "#   Recall (sensitivity, true positive rate) = TP / (TP + FN)\n",
    "#       TP = #true positives (correctly predicted '5'),\n",
    "#       FP = #false positives (falsely predicted '5'),\n",
    "#       FN = #false negatives (falsely predicted non-'5')\n",
    "\n",
    "from sklearn.linear_model import SGDClassifier\n",
    "model = SGDClassifier(random_state = 42)\n",
    "model.fit(X_train, y_train_5)\n",
    "prediction = model.predict(X_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[52316,  2263],\n",
       "       [  601,  4820]], dtype=int64)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Confusion matrix\n",
    "#   A 2x2 matrix with four elements: actual class (rows), predicted class (column)\n",
    "from sklearn.metrics import confusion_matrix\n",
    "matrix = confusion_matrix(y_train_5, prediction)\n",
    "matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Precision: 0.68050\n",
      "Recall: 0.88913\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import precision_score, recall_score\n",
    "precision = precision_score(y_train_5, prediction)\n",
    "recall = recall_score(y_train_5, prediction)\n",
    "\n",
    "print(f\"Precision: {precision:.5f}\")    # 4820 / (4820 + 2263)\n",
    "print(f\"Recall: {recall:.5f}\")          # 4820 / (4820 + 601)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.7709532949456175\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import f1_score\n",
    "print(f1_score(y_train_5, prediction))"
   ]
  }
 ],
 "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.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}