95-865 Prediction and Model Validation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 95-865: Prediction and Model Validation\n",
    "\n",
    "Author: George H. Chen (georgechen [at symbol] cmu.edu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "import torchvision\n",
    "import torchvision.transforms as transforms\n",
    "\n",
    "np.random.seed(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loading in the data and a quick data inspection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_dataset = torchvision.datasets.MNIST(root='data/',\n",
    "                                           train=True,\n",
    "                                           transform=transforms.ToTensor(),\n",
    "                                           download=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_images = np.array([image.numpy() for image, label in train_dataset])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_labels = np.array([label for image, label in train_dataset])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(60000, 1, 28, 28)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_images.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 0, 4, ..., 5, 6, 8])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f7ed4157340>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaEAAAGdCAYAAAC7EMwUAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAaI0lEQVR4nO3df2jU9x3H8dfVH1d1lytBk7vUmGVF202dpWrVYP3R1cxApf4oWMtGZEPa+YOJ/cGsDNNBjdgpRdI6V0amW239Y9a6KdUMTXRkijpdRYtYjDOdCcFM72LUSMxnf4hHz1j1e975vkueD/iCufu+vY/ffuvTby75xueccwIAwMBD1gsAAHRfRAgAYIYIAQDMECEAgBkiBAAwQ4QAAGaIEADADBECAJjpab2AW3V0dOjcuXMKBALy+XzWywEAeOScU0tLi/Ly8vTQQ3e+1km7CJ07d075+fnWywAA3Kf6+noNHDjwjvuk3afjAoGA9RIAAElwL3+fpyxCH3zwgQoLC/Xwww9r5MiR2rdv3z3N8Sk4AOga7uXv85REaPPmzVq8eLGWLVumI0eO6JlnnlFJSYnOnj2bipcDAGQoXyruoj1mzBg99dRTWrduXeyx73//+5o+fbrKy8vvOBuNRhUMBpO9JADAAxaJRJSVlXXHfZJ+JXTt2jUdPnxYxcXFcY8XFxertra20/5tbW2KRqNxGwCge0h6hM6fP6/r168rNzc37vHc3Fw1NjZ22r+8vFzBYDC28ZVxANB9pOwLE259Q8o5d9s3qZYuXapIJBLb6uvrU7UkAECaSfr3CfXv3189evTodNXT1NTU6epIkvx+v/x+f7KXAQDIAEm/Eurdu7dGjhypqqqquMerqqpUVFSU7JcDAGSwlNwxYcmSJfrpT3+qUaNGady4cfr973+vs2fP6tVXX03FywEAMlRKIjR79mw1NzfrN7/5jRoaGjRs2DDt2LFDBQUFqXg5AECGSsn3Cd0Pvk8IALoGk+8TAgDgXhEhAIAZIgQAMEOEAABmiBAAwAwRAgCYIUIAADNECABghggBAMwQIQCAGSIEADBDhAAAZogQAMAMEQIAmCFCAAAzRAgAYIYIAQDMECEAgBkiBAAwQ4QAAGaIEADADBECAJghQgAAM0QIAGCGCAEAzBAhAIAZIgQAMEOEAABmiBAAwAwRAgCYIUIAADNECABghggBAMwQIQCAGSIEADBDhAAAZogQAMAMEQIAmCFCAAAzRAgAYIYIAQDMECEAgBkiBAAwQ4QAAGaIEADADBECAJghQgAAM0QIAGCGCAEAzBAhAIAZIgQAMEOEAABmelovAEgnPXr08DwTDAZTsJLkWLhwYUJzffv29Tzz+OOPe55ZsGCB55nf/va3nmfmzJnjeUaSrl696nlm5cqVnmfefvttzzNdBVdCAAAzRAgAYCbpESorK5PP54vbQqFQsl8GANAFpOQ9oaFDh+rvf/977ONEPs8OAOj6UhKhnj17cvUDALirlLwndOrUKeXl5amwsFAvvfSSTp8+/a37trW1KRqNxm0AgO4h6REaM2aMNm7cqJ07d+rDDz9UY2OjioqK1NzcfNv9y8vLFQwGY1t+fn6ylwQASFNJj1BJSYlmzZql4cOH67nnntP27dslSRs2bLjt/kuXLlUkEolt9fX1yV4SACBNpfybVfv166fhw4fr1KlTt33e7/fL7/enehkAgDSU8u8Tamtr05dffqlwOJzqlwIAZJikR+j1119XTU2N6urqdODAAb344ouKRqMqLS1N9ksBADJc0j8d9/XXX2vOnDk6f/68BgwYoLFjx2r//v0qKChI9ksBADJc0iP0ySefJPu3RJoaNGiQ55nevXt7nikqKvI8M378eM8zkvTII494npk1a1ZCr9XVfP31155n1q5d63lmxowZnmdaWlo8z0jSv//9b88zNTU1Cb1Wd8W94wAAZogQAMAMEQIAmCFCAAAzRAgAYIYIAQDMECEAgBkiBAAwQ4QAAGaIEADADBECAJghQgAAMz7nnLNexDdFo1EFg0HrZXQrTz75ZEJzu3fv9jzDf9vM0NHR4XnmZz/7meeZS5cueZ5JRENDQ0JzFy5c8Dxz8uTJhF6rK4pEIsrKyrrjPlwJAQDMECEAgBkiBAAwQ4QAAGaIEADADBECAJghQgAAM0QIAGCGCAEAzBAhAIAZIgQAMEOEAABmiBAAwExP6wXA3tmzZxOaa25u9jzDXbRvOHDggOeZixcvep6ZPHmy5xlJunbtmueZP/3pTwm9Fro3roQAAGaIEADADBECAJghQgAAM0QIAGCGCAEAzBAhAIAZIgQAMEOEAABmiBAAwAwRAgCYIUIAADPcwBT63//+l9DcG2+84Xnm+eef9zxz5MgRzzNr1671PJOoo0ePep6ZMmWK55nW1lbPM0OHDvU8I0m//OUvE5oDvOJKCABghggBAMwQIQCAGSIEADBDhAAAZogQAMAMEQIAmCFCAAAzRAgAYIYIAQDMECEAgBkiBAAw43POOetFfFM0GlUwGLReBlIkKyvL80xLS4vnmfXr13uekaSf//znnmd+8pOfeJ75+OOPPc8AmSYSidz1/3muhAAAZogQAMCM5wjt3btX06ZNU15ennw+n7Zu3Rr3vHNOZWVlysvLU58+fTRp0iQdP348WesFAHQhniPU2tqqESNGqKKi4rbPr1q1SmvWrFFFRYUOHjyoUCikKVOmJPR5fQBA1+b5J6uWlJSopKTkts855/Tee+9p2bJlmjlzpiRpw4YNys3N1aZNm/TKK6/c32oBAF1KUt8TqqurU2Njo4qLi2OP+f1+TZw4UbW1tbedaWtrUzQajdsAAN1DUiPU2NgoScrNzY17PDc3N/bcrcrLyxUMBmNbfn5+MpcEAEhjKfnqOJ/PF/exc67TYzctXbpUkUgkttXX16diSQCANOT5PaE7CYVCkm5cEYXD4djjTU1Nna6ObvL7/fL7/clcBgAgQyT1SqiwsFChUEhVVVWxx65du6aamhoVFRUl86UAAF2A5yuhS5cu6auvvop9XFdXp6NHjyo7O1uDBg3S4sWLtWLFCg0ePFiDBw/WihUr1LdvX7388stJXTgAIPN5jtChQ4c0efLk2MdLliyRJJWWluqPf/yj3nzzTV25ckXz58/XhQsXNGbMGO3atUuBQCB5qwYAdAncwBRd0rvvvpvQ3M1/VHlRU1Pjeea5557zPNPR0eF5BrDEDUwBAGmNCAEAzBAhAIAZIgQAMEOEAABmiBAAwAwRAgCYIUIAADNECABghggBAMwQIQCAGSIEADBDhAAAZriLNrqkfv36JTT317/+1fPMxIkTPc+UlJR4ntm1a5fnGcASd9EGAKQ1IgQAMEOEAABmiBAAwAwRAgCYIUIAADNECABghggBAMwQIQCAGSIEADBDhAAAZogQAMAMNzAFvuGxxx7zPPOvf/3L88zFixc9z+zZs8fzzKFDhzzPSNL777/veSbN/ipBGuAGpgCAtEaEAABmiBAAwAwRAgCYIUIAADNECABghggBAMwQIQCAGSIEADBDhAAAZogQAMAMEQIAmOEGpsB9mjFjhueZyspKzzOBQMDzTKLeeustzzMbN270PNPQ0OB5BpmDG5gCANIaEQIAmCFCAAAzRAgAYIYIAQDMECEAgBkiBAAwQ4QAAGaIEADADBECAJghQgAAM0QIAGCGG5gCBoYNG+Z5Zs2aNZ5nfvSjH3meSdT69es9z7zzzjueZ/773/96noENbmAKAEhrRAgAYMZzhPbu3atp06YpLy9PPp9PW7dujXt+7ty58vl8cdvYsWOTtV4AQBfiOUKtra0aMWKEKioqvnWfqVOnqqGhIbbt2LHjvhYJAOiaenodKCkpUUlJyR338fv9CoVCCS8KANA9pOQ9oerqauXk5GjIkCGaN2+empqavnXftrY2RaPRuA0A0D0kPUIlJSX66KOPtHv3bq1evVoHDx7Us88+q7a2ttvuX15ermAwGNvy8/OTvSQAQJry/Om4u5k9e3bs18OGDdOoUaNUUFCg7du3a+bMmZ32X7p0qZYsWRL7OBqNEiIA6CaSHqFbhcNhFRQU6NSpU7d93u/3y+/3p3oZAIA0lPLvE2publZ9fb3C4XCqXwoAkGE8XwldunRJX331Vezjuro6HT16VNnZ2crOzlZZWZlmzZqlcDisM2fO6K233lL//v01Y8aMpC4cAJD5PEfo0KFDmjx5cuzjm+/nlJaWat26dTp27Jg2btyoixcvKhwOa/Lkydq8ebMCgUDyVg0A6BK4gSmQIR555BHPM9OmTUvotSorKz3P+Hw+zzO7d+/2PDNlyhTPM7DBDUwBAGmNCAEAzBAhAIAZIgQAMEOEAABmiBAAwAwRAgCYIUIAADNECABghggBAMwQIQCAGSIEADBDhAAAZriLNoBO2traPM/07On9BzW3t7d7nvnxj3/seaa6utrzDO4fd9EGAKQ1IgQAMEOEAABmiBAAwAwRAgCYIUIAADNECABghggBAMwQIQCAGSIEADBDhAAAZogQAMCM9zsOArhvP/zhDz3PvPjii55nRo8e7XlGSuxmpIk4ceKE55m9e/emYCWwwpUQAMAMEQIAmCFCAAAzRAgAYIYIAQDMECEAgBkiBAAwQ4QAAGaIEADADBECAJghQgAAM0QIAGCGG5gC3/D44497nlm4cKHnmZkzZ3qeCYVCnmcepOvXr3ueaWho8DzT0dHheQbpiyshAIAZIgQAMEOEAABmiBAAwAwRAgCYIUIAADNECABghggBAMwQIQCAGSIEADBDhAAAZogQAMAMNzBF2kvkxp1z5sxJ6LUSuRnpd7/73YReK50dOnTI88w777zjeWbbtm2eZ9C1cCUEADBDhAAAZjxFqLy8XKNHj1YgEFBOTo6mT5+ukydPxu3jnFNZWZny8vLUp08fTZo0ScePH0/qogEAXYOnCNXU1GjBggXav3+/qqqq1N7eruLiYrW2tsb2WbVqldasWaOKigodPHhQoVBIU6ZMUUtLS9IXDwDIbJ6+MOHzzz+P+7iyslI5OTk6fPiwJkyYIOec3nvvPS1btiz2kyM3bNig3Nxcbdq0Sa+88kryVg4AyHj39Z5QJBKRJGVnZ0uS6urq1NjYqOLi4tg+fr9fEydOVG1t7W1/j7a2NkWj0bgNANA9JBwh55yWLFmi8ePHa9iwYZKkxsZGSVJubm7cvrm5ubHnblVeXq5gMBjb8vPzE10SACDDJByhhQsX6osvvtDHH3/c6Tmfzxf3sXOu02M3LV26VJFIJLbV19cnuiQAQIZJ6JtVFy1apG3btmnv3r0aOHBg7PGb31TY2NiocDgce7ypqanT1dFNfr9ffr8/kWUAADKcpysh55wWLlyoLVu2aPfu3SosLIx7vrCwUKFQSFVVVbHHrl27ppqaGhUVFSVnxQCALsPTldCCBQu0adMmffbZZwoEArH3eYLBoPr06SOfz6fFixdrxYoVGjx4sAYPHqwVK1aob9++evnll1PyBwAAZC5PEVq3bp0kadKkSXGPV1ZWau7cuZKkN998U1euXNH8+fN14cIFjRkzRrt27VIgEEjKggEAXYfPOeesF/FN0WhUwWDQehm4B9/2Pt+d/OAHP/A8U1FR4XnmiSee8DyT7g4cOOB55t13303otT777DPPMx0dHQm9FrquSCSirKysO+7DveMAAGaIEADADBECAJghQgAAM0QIAGCGCAEAzBAhAIAZIgQAMEOEAABmiBAAwAwRAgCYIUIAADNECABgJqGfrIr0lZ2d7Xlm/fr1Cb3Wk08+6Xnme9/7XkKvlc5qa2s9z6xevdrzzM6dOz3PXLlyxfMM8CBxJQQAMEOEAABmiBAAwAwRAgCYIUIAADNECABghggBAMwQIQCAGSIEADBDhAAAZogQAMAMEQIAmOEGpg/ImDFjPM+88cYbnmeefvppzzOPPvqo55l0d/ny5YTm1q5d63lmxYoVnmdaW1s9zwBdEVdCAAAzRAgAYIYIAQDMECEAgBkiBAAwQ4QAAGaIEADADBECAJghQgAAM0QIAGCGCAEAzBAhAIAZbmD6gMyYMeOBzDxIJ06c8Dzzt7/9zfNMe3u755nVq1d7npGkixcvJjQHIDFcCQEAzBAhAIAZIgQAMEOEAABmiBAAwAwRAgCYIUIAADNECABghggBAMwQIQCAGSIEADBDhAAAZnzOOWe9iG+KRqMKBoPWywAA3KdIJKKsrKw77sOVEADADBECAJjxFKHy8nKNHj1agUBAOTk5mj59uk6ePBm3z9y5c+Xz+eK2sWPHJnXRAICuwVOEampqtGDBAu3fv19VVVVqb29XcXGxWltb4/abOnWqGhoaYtuOHTuSumgAQNfg6Serfv7553EfV1ZWKicnR4cPH9aECRNij/v9foVCoeSsEADQZd3Xe0KRSESSlJ2dHfd4dXW1cnJyNGTIEM2bN09NTU3f+nu0tbUpGo3GbQCA7iHhL9F2zumFF17QhQsXtG/fvtjjmzdv1ne+8x0VFBSorq5Ov/71r9Xe3q7Dhw/L7/d3+n3Kysr09ttvJ/4nAACkpXv5Em25BM2fP98VFBS4+vr6O+537tw516tXL/eXv/zlts9fvXrVRSKR2FZfX+8ksbGxsbFl+BaJRO7aEk/vCd20aNEibdu2TXv37tXAgQPvuG84HFZBQYFOnTp12+f9fv9tr5AAAF2fpwg557Ro0SJ9+umnqq6uVmFh4V1nmpubVV9fr3A4nPAiAQBdk6cvTFiwYIH+/Oc/a9OmTQoEAmpsbFRjY6OuXLkiSbp06ZJef/11/fOf/9SZM2dUXV2tadOmqX///poxY0ZK/gAAgAzm5X0gfcvn/SorK51zzl2+fNkVFxe7AQMGuF69erlBgwa50tJSd/bs2Xt+jUgkYv55TDY2Nja2+9/u5T0hbmAKAEgJbmAKAEhrRAgAYIYIAQDMECEAgBkiBAAwQ4QAAGaIEADADBECAJghQgAAM0QIAGCGCAEAzBAhAIAZIgQAMEOEAABmiBAAwAwRAgCYIUIAADNECABghggBAMwQIQCAGSIEADBDhAAAZogQAMAMEQIAmCFCAAAzaRch55z1EgAASXAvf5+nXYRaWlqslwAASIJ7+fvc59Ls0qOjo0Pnzp1TIBCQz+eLey4ajSo/P1/19fXKysoyWqE9jsMNHIcbOA43cBxuSIfj4JxTS0uL8vLy9NBDd77W6fmA1nTPHnroIQ0cOPCO+2RlZXXrk+wmjsMNHIcbOA43cBxusD4OwWDwnvZLu0/HAQC6DyIEADCTURHy+/1avny5/H6/9VJMcRxu4DjcwHG4geNwQ6Ydh7T7wgQAQPeRUVdCAICuhQgBAMwQIQCAGSIEADCTURH64IMPVFhYqIcfflgjR47Uvn37rJf0QJWVlcnn88VtoVDIelkpt3fvXk2bNk15eXny+XzaunVr3PPOOZWVlSkvL099+vTRpEmTdPz4cZvFptDdjsPcuXM7nR9jx461WWyKlJeXa/To0QoEAsrJydH06dN18uTJuH26w/lwL8chU86HjInQ5s2btXjxYi1btkxHjhzRM888o5KSEp09e9Z6aQ/U0KFD1dDQENuOHTtmvaSUa21t1YgRI1RRUXHb51etWqU1a9aooqJCBw8eVCgU0pQpU7rcfQjvdhwkaerUqXHnx44dOx7gClOvpqZGCxYs0P79+1VVVaX29nYVFxertbU1tk93OB/u5ThIGXI+uAzx9NNPu1dffTXusSeeeML96le/MlrRg7d8+XI3YsQI62WYkuQ+/fTT2McdHR0uFAq5lStXxh67evWqCwaD7ne/+53BCh+MW4+Dc86Vlpa6F154wWQ9VpqampwkV1NT45zrvufDrcfBucw5HzLiSujatWs6fPiwiouL4x4vLi5WbW2t0apsnDp1Snl5eSosLNRLL72k06dPWy/JVF1dnRobG+PODb/fr4kTJ3a7c0OSqqurlZOToyFDhmjevHlqamqyXlJKRSIRSVJ2drak7ns+3HocbsqE8yEjInT+/Hldv35dubm5cY/n5uaqsbHRaFUP3pgxY7Rx40bt3LlTH374oRobG1VUVKTm5mbrpZm5+d+/u58bklRSUqKPPvpIu3fv1urVq3Xw4EE9++yzamtrs15aSjjntGTJEo0fP17Dhg2T1D3Ph9sdBylzzoe0u4v2ndz6ox2cc50e68pKSkpivx4+fLjGjRunxx57TBs2bNCSJUsMV2avu58bkjR79uzYr4cNG6ZRo0apoKBA27dv18yZMw1XlhoLFy7UF198oX/84x+dnutO58O3HYdMOR8y4kqof//+6tGjR6d/yTQ1NXX6F0930q9fPw0fPlynTp2yXoqZm18dyLnRWTgcVkFBQZc8PxYtWqRt27Zpz549cT/6pbudD992HG4nXc+HjIhQ7969NXLkSFVVVcU9XlVVpaKiIqNV2Wtra9OXX36pcDhsvRQzhYWFCoVCcefGtWvXVFNT063PDUlqbm5WfX19lzo/nHNauHChtmzZot27d6uwsDDu+e5yPtztONxO2p4Phl8U4cknn3zievXq5f7whz+4EydOuMWLF7t+/fq5M2fOWC/tgXnttddcdXW1O336tNu/f797/vnnXSAQ6PLHoKWlxR05csQdOXLESXJr1qxxR44ccf/5z3+cc86tXLnSBYNBt2XLFnfs2DE3Z84cFw6HXTQaNV55ct3pOLS0tLjXXnvN1dbWurq6Ordnzx43btw49+ijj3ap4/CLX/zCBYNBV11d7RoaGmLb5cuXY/t0h/Phbschk86HjImQc869//77rqCgwPXu3ds99dRTcV+O2B3Mnj3bhcNh16tXL5eXl+dmzpzpjh8/br2slNuzZ4+T1GkrLS11zt34stzly5e7UCjk/H6/mzBhgjt27JjtolPgTsfh8uXLrri42A0YMMD16tXLDRo0yJWWlrqzZ89aLzupbvfnl+QqKytj+3SH8+FuxyGTzgd+lAMAwExGvCcEAOiaiBAAwAwRAgCYIUIAADNECABghggBAMwQIQCAGSIEADBDhAAAZogQAMAMEQIAmCFCAAAz/wdVbyhNmNF0pQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(train_images[0][0], cmap='gray')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_images = train_images[:2000]\n",
    "train_labels = train_labels[:2000]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_images_flat = train_images.reshape(len(train_images), -1)  # flattens out each training image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2000, 784)\n"
     ]
    }
   ],
   "source": [
    "print(train_images_flat.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Classification using $k$-nearest neighbors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>#sk-container-id-1 {color: black;background-color: white;}#sk-container-id-1 pre{padding: 0;}#sk-container-id-1 div.sk-toggleable {background-color: white;}#sk-container-id-1 label.sk-toggleable__label {cursor: pointer;display: block;width: 100%;margin-bottom: 0;padding: 0.3em;box-sizing: border-box;text-align: center;}#sk-container-id-1 label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-1 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-1 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-1 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-1 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-1 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-1 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-container-id-1 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 input.sk-hidden--visually {border: 0;clip: rect(1px 1px 1px 1px);clip: rect(1px, 1px, 1px, 1px);height: 1px;margin: -1px;overflow: hidden;padding: 0;position: absolute;width: 1px;}#sk-container-id-1 div.sk-estimator {font-family: monospace;background-color: #f0f8ff;border: 1px dotted black;border-radius: 0.25em;box-sizing: border-box;margin-bottom: 0.5em;}#sk-container-id-1 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-1 div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-1 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-serial::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: 0;}#sk-container-id-1 div.sk-serial {display: flex;flex-direction: column;align-items: center;background-color: white;padding-right: 0.2em;padding-left: 0.2em;position: relative;}#sk-container-id-1 div.sk-item {position: relative;z-index: 1;}#sk-container-id-1 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-1 div.sk-item::before, #sk-container-id-1 div.sk-parallel-item::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: -1;}#sk-container-id-1 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-1 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-1 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-1 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-1 div.sk-dashed-wrapped {border: 1px dashed gray;margin: 0 0.4em 0.5em 0.4em;box-sizing: border-box;padding-bottom: 0.4em;background-color: white;}#sk-container-id-1 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-1 div.sk-label-container {text-align: center;}#sk-container-id-1 div.sk-container {/* jupyter's `normalize.less` sets `[hidden] { display: none; }` but bootstrap.min.css set `[hidden] { display: none !important; }` so we also need the `!important` here to be able to override the default hidden behavior on the sphinx rendered scikit-learn.org. See: https://github.com/scikit-learn/scikit-learn/issues/21755 */display: inline-block !important;position: relative;}#sk-container-id-1 div.sk-text-repr-fallback {display: none;}</style><div id=\"sk-container-id-1\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>KNeighborsClassifier(n_neighbors=1)</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-1\" type=\"checkbox\" checked><label for=\"sk-estimator-id-1\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">KNeighborsClassifier</label><div class=\"sk-toggleable__content\"><pre>KNeighborsClassifier(n_neighbors=1)</pre></div></div></div></div></div>"
      ],
      "text/plain": [
       "KNeighborsClassifier(n_neighbors=1)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "classifier = KNeighborsClassifier(n_neighbors=1)\n",
    "classifier.fit(train_images_flat, train_labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "predicted_train_labels = classifier.predict(train_images_flat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 0, 4, ..., 5, 2, 0])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predicted_train_labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False, False, ..., False, False, False])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predicted_train_labels != train_labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0\n"
     ]
    }
   ],
   "source": [
    "error_rate = np.mean(predicted_train_labels != train_labels)\n",
    "print(error_rate)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Choosing hyperparameter $k$ (number of nearest neighbors) using simple data splitting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "proper_train_images_flat, val_images_flat, proper_train_labels, val_labels = \\\n",
    "    train_test_split(train_images_flat, train_labels, test_size=0.2, random_state=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "k: 1 error rate: 0.1075\n",
      "k: 2 error rate: 0.13\n",
      "k: 4 error rate: 0.1325\n",
      "k: 8 error rate: 0.1475\n",
      "k: 16 error rate: 0.1675\n",
      "k: 32 error rate: 0.2025\n",
      "k: 64 error rate: 0.26\n",
      "k: 128 error rate: 0.33\n",
      "Best k: 1 error rate: 0.1075\n"
     ]
    }
   ],
   "source": [
    "lowest_error = np.inf\n",
    "best_k = None\n",
    "for k in 2**np.arange(0, 8):\n",
    "    classifier = KNeighborsClassifier(n_neighbors=k)\n",
    "    classifier.fit(proper_train_images_flat, proper_train_labels)\n",
    "    predicted_val_labels = classifier.predict(val_images_flat)\n",
    "    error = np.mean(predicted_val_labels != val_labels)\n",
    "    print('k:', k, 'error rate:', error)\n",
    "    \n",
    "    if error < lowest_error:\n",
    "        lowest_error = error\n",
    "        best_k = k\n",
    "\n",
    "print('Best k:', best_k, 'error rate:', lowest_error)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Choosing hyperparameter $k$ using 5-fold cross validation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "k: 1 cross validation error: 0.092\n",
      "k: 2 cross validation error: 0.10899999999999999\n",
      "k: 4 cross validation error: 0.10400000000000001\n",
      "k: 8 cross validation error: 0.1115\n",
      "k: 16 cross validation error: 0.1335\n",
      "k: 32 cross validation error: 0.1595\n",
      "k: 64 cross validation error: 0.198\n",
      "k: 128 cross validation error: 0.269\n",
      "Best k: 1 cross validation error: 0.092\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import KFold\n",
    "\n",
    "lowest_cross_val_error = np.inf\n",
    "best_k = None\n",
    "\n",
    "kf = KFold(n_splits=5, shuffle=True, random_state=0)\n",
    "for k in 2**np.arange(0, 8):\n",
    "    errors = []\n",
    "    for proper_train_indices, val_indices in kf.split(train_images_flat):\n",
    "        proper_train_features = train_images_flat[proper_train_indices]\n",
    "        proper_train_labels = train_labels[proper_train_indices]\n",
    "        val_features = train_images_flat[val_indices]\n",
    "        val_labels = train_labels[val_indices]\n",
    "        \n",
    "        classifier = KNeighborsClassifier(n_neighbors=k)\n",
    "        classifier.fit(proper_train_features, proper_train_labels)\n",
    "        predicted_val_labels = classifier.predict(val_features)\n",
    "        error = np.mean(predicted_val_labels != val_labels)\n",
    "        errors.append(error)\n",
    "    \n",
    "    cross_val_error = np.mean(errors)\n",
    "    print('k:', k, 'cross validation error:', cross_val_error)\n",
    "\n",
    "    if cross_val_error < lowest_cross_val_error:\n",
    "        lowest_cross_val_error = cross_val_error\n",
    "        best_k = k\n",
    "\n",
    "print('Best k:', best_k, 'cross validation error:', lowest_cross_val_error)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using different classifiers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's simple to work with other classifiers in scikit-learn. For example, here is how one can use random forest classifiers using the number of random features to use at each split (`max_features`) and the minimum number of samples allowed in a leaf cell (`min_samples_leaf`) as hyperparameters (there are other hyperparameters as well, but we're just using the scikit-learn default values in this demo--if you care about actually tuning the performance of a random forest classifier carefully, then you should look into what the other hyperparameters do by reading the documentation). Note that the default number of trees used (which can also be manually set via the parameter `n_estimators`) is 100."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/george/anaconda3_UDA/lib/python3.9/site-packages/sklearn/ensemble/_forest.py:424: FutureWarning: `max_features='auto'` has been deprecated in 1.1 and will be removed in 1.3. To keep the past behaviour, explicitly set `max_features='sqrt'` or remove this parameter as it is also the default value for RandomForestClassifiers and ExtraTreesClassifiers.\n",
      "  warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0\n"
     ]
    }
   ],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "rf_classifier = RandomForestClassifier(n_estimators=100,\n",
    "                                       max_features='auto',\n",
    "                                       min_samples_leaf=1,\n",
    "                                       random_state=0)\n",
    "rf_classifier.fit(train_images_flat, train_labels)\n",
    "rf_predicted_train_labels = rf_classifier.predict(train_images_flat)\n",
    "rf_error = np.mean(rf_predicted_train_labels != train_labels)\n",
    "print(rf_error)  # training set error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we see cross-validation for random forests. Importantly, now we sweep over two hyperparameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_features = train_images_flat.shape[1]\n",
    "hyperparameter_settings = [(max_features, min_samples_leaf)\n",
    "                           for max_features in [int(np.ceil(np.sqrt(num_features) / 4)),\n",
    "                                                int(np.ceil(np.sqrt(num_features))),\n",
    "                                                int(np.ceil(np.sqrt(num_features) * 4))]\n",
    "                           for min_samples_leaf in [1, 2, 4, 8, 16]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(7, 1),\n",
       " (7, 2),\n",
       " (7, 4),\n",
       " (7, 8),\n",
       " (7, 16),\n",
       " (28, 1),\n",
       " (28, 2),\n",
       " (28, 4),\n",
       " (28, 8),\n",
       " (28, 16),\n",
       " (112, 1),\n",
       " (112, 2),\n",
       " (112, 4),\n",
       " (112, 8),\n",
       " (112, 16)]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hyperparameter_settings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hyperparameter: (7, 1) cross validation error: 0.0895\n",
      "Hyperparameter: (7, 2) cross validation error: 0.09\n",
      "Hyperparameter: (7, 4) cross validation error: 0.10599999999999998\n",
      "Hyperparameter: (7, 8) cross validation error: 0.127\n",
      "Hyperparameter: (7, 16) cross validation error: 0.1485\n",
      "Hyperparameter: (28, 1) cross validation error: 0.08549999999999999\n",
      "Hyperparameter: (28, 2) cross validation error: 0.093\n",
      "Hyperparameter: (28, 4) cross validation error: 0.09200000000000001\n",
      "Hyperparameter: (28, 8) cross validation error: 0.1135\n",
      "Hyperparameter: (28, 16) cross validation error: 0.14350000000000002\n",
      "Hyperparameter: (112, 1) cross validation error: 0.08600000000000001\n",
      "Hyperparameter: (112, 2) cross validation error: 0.09100000000000001\n",
      "Hyperparameter: (112, 4) cross validation error: 0.099\n",
      "Hyperparameter: (112, 8) cross validation error: 0.11599999999999999\n",
      "Hyperparameter: (112, 16) cross validation error: 0.14900000000000002\n",
      "Best hyperparameter: (28, 1) cross validation error: 0.08549999999999999\n"
     ]
    }
   ],
   "source": [
    "lowest_cross_val_error = np.inf\n",
    "best_hyperparameter_setting = None\n",
    "\n",
    "kf = KFold(n_splits=5, shuffle=True, random_state=0)\n",
    "for hyperparameter_setting in hyperparameter_settings:\n",
    "    max_features, min_samples_leaf = hyperparameter_setting\n",
    "    errors = []\n",
    "    for proper_train_indices, val_indices in kf.split(train_images_flat):\n",
    "        proper_train_features = train_images_flat[proper_train_indices]\n",
    "        proper_train_labels = train_labels[proper_train_indices]\n",
    "        val_features = train_images_flat[val_indices]\n",
    "        val_labels = train_labels[val_indices]\n",
    "        \n",
    "        classifier = RandomForestClassifier(max_features=max_features,\n",
    "                                            min_samples_leaf=min_samples_leaf,\n",
    "                                            random_state=0)\n",
    "        classifier.fit(proper_train_features, proper_train_labels)\n",
    "        predicted_val_labels = classifier.predict(val_features)\n",
    "        error = np.mean(predicted_val_labels != val_labels)\n",
    "        errors.append(error)\n",
    "        \n",
    "    cross_val_error = np.mean(errors)\n",
    "    print('Hyperparameter:', hyperparameter_setting, 'cross validation error:', cross_val_error)\n",
    "\n",
    "    if cross_val_error < lowest_cross_val_error:\n",
    "        lowest_cross_val_error = cross_val_error\n",
    "        best_hyperparameter_setting = hyperparameter_setting\n",
    "\n",
    "print('Best hyperparameter:', best_hyperparameter_setting, 'cross validation error:', lowest_cross_val_error)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Finally actually looking at the test data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_dataset = torchvision.datasets.MNIST(root='data/',\n",
    "                                          train=False,\n",
    "                                          transform=transforms.ToTensor(),\n",
    "                                          download=True)\n",
    "test_images = np.array([image.numpy() for image, label in test_dataset])\n",
    "test_labels = np.array([label for image, label in test_dataset])\n",
    "\n",
    "test_images = test_images[:500]\n",
    "test_labels = test_labels[:500]\n",
    "test_images_flat = test_images.reshape(len(test_images), -1)  # flattens out each test image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.138\n"
     ]
    }
   ],
   "source": [
    "final_knn_classifier = KNeighborsClassifier(n_neighbors=best_k)\n",
    "final_knn_classifier.fit(train_images_flat, train_labels)\n",
    "predicted_test_labels = final_knn_classifier.predict(test_images_flat)\n",
    "test_set_error = np.mean(predicted_test_labels != test_labels)\n",
    "print(test_set_error)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.09\n"
     ]
    }
   ],
   "source": [
    "best_max_features, best_min_samples_split = best_hyperparameter_setting\n",
    "final_rf_classifier = RandomForestClassifier(max_features=best_max_features,\n",
    "                                             min_samples_leaf=best_min_samples_split,\n",
    "                                             random_state=0)\n",
    "final_rf_classifier.fit(train_images_flat, train_labels)\n",
    "predicted_test_labels = final_rf_classifier.predict(test_images_flat)\n",
    "test_set_error = np.mean(predicted_test_labels != test_labels)\n",
    "print(test_set_error)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that in general the cross validation error is not going to perfectly match up with the test set error."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Confusion matrix\n",
    "\n",
    "We can visualize to see where (in terms of which classes) predictions agree or disagree with the true labels on the test set. This can help us quickly see which classes seem to be hard cases."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<sklearn.metrics._plot.confusion_matrix.ConfusionMatrixDisplay at 0x7f7eac603d30>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "cm = confusion_matrix(test_labels, final_knn_classifier.predict(test_images_flat),\n",
    "                      labels=final_knn_classifier.classes_)\n",
    "ConfusionMatrixDisplay(confusion_matrix=cm,\n",
    "                       display_labels=final_knn_classifier.classes_).plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<sklearn.metrics._plot.confusion_matrix.ConfusionMatrixDisplay at 0x7f7eac5ac2b0>"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "cm = confusion_matrix(test_labels, final_rf_classifier.predict(test_images_flat),\n",
    "                      labels=final_rf_classifier.classes_)\n",
    "ConfusionMatrixDisplay(confusion_matrix=cm,\n",
    "                       display_labels=final_rf_classifier.classes_).plot()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}