{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Kuzushiji Classification with Support Vector Machines\n",
    "\n",
    "In this notebook we are going to explore the use of Support Vector Machines (SVM) for image classification. We will use a variant of the famous MNIST dataset (the original is a dataset of handwritten digits). The version we are going to use is called Kuzushiji-MNIST or K-MNIST for short (https://github.com/rois-codh/kmnist) and is a dataset of traditional japanese handwritten kana.\n",
    "\n",
    "\n",
    "\n",
    "The dataset labels are the following:\n",
    "\n",
    "| Label | Hiragana Character | Romanji (Pronunciation) |\n",
    "| :-: | :-: | :-: |\n",
    "|   0   | お | o |\n",
    "| 1 | き | ki |\n",
    "| 2 | す | su |\n",
    "| 3 | つ | tsu |\n",
    "| 4 | な | na |\n",
    "| 5 | は | ha |\n",
    "| 6 | ま | ma |\n",
    "| 7 | や | ya |\n",
    "| 8 | れ | re |\n",
    "| 9 | を | wo |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## TODO: Insert your surname, name and ID number\n",
    "\n",
    "Student surname:\n",
    "\n",
    "Student name:\n",
    "    \n",
    "ID:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#load the required packages\n",
    "\n",
    "%matplotlib inline  \n",
    "\n",
    "import numpy as np\n",
    "import scipy as sp\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import sklearn\n",
    "from sklearn.datasets import fetch_openml\n",
    "from sklearn.neural_network import MLPClassifier\n",
    "from sklearn.decomposition import PCA\n",
    "import sklearn.metrics as skm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# helper function to load Kuzhuzhiji MNIST dataset\n",
    "def load_mnist(path, kind='train'):\n",
    "    import os\n",
    "    import gzip\n",
    "    import numpy as np\n",
    "    labels_path = os.path.join(path, 'K%s-labels-idx1-ubyte.gz' % kind)\n",
    "    images_path = os.path.join(path, 'K%s-images-idx3-ubyte.gz' % kind)\n",
    "    with gzip.open(labels_path, 'rb') as lbpath:\n",
    "        labels = np.frombuffer(lbpath.read(), dtype=np.uint8,offset=8)\n",
    "    with gzip.open(images_path, 'rb') as imgpath:\n",
    "        images = np.frombuffer(imgpath.read(), dtype=np.uint8,offset=16).reshape(len(labels), 784)\n",
    "    return images, labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#fix your ID (\"numero di matricola\") and the seed for random generator (as usual you can try different seeds)\n",
    "ID = 3444567\n",
    "np.random.seed(ID)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(60000, 784) (60000,)\n"
     ]
    }
   ],
   "source": [
    "#load the Kuzhuzhiji MNIST dataset from the 'data' folder and let's normalize the features so that each value is in [0,1] \n",
    "\n",
    "#X, y = np.load(\"data/svhn_images.npy\").reshape(-1, 24*24), np.load(\"data/svhn_labels.npy\")\n",
    "X, y = load_mnist('data', kind='train')\n",
    "# rescale the data\n",
    "X, y = X / 255., y # original pixel values are between 0 and 255\n",
    "print(X.shape, y.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now split into training and test. Make sure that each label is present at least 10 times\n",
    "in training. If it is not, then keep adding permutations to the initial data until this \n",
    "happens."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(600, 784) (4000, 784) (600,) (4000,)\n",
      "Labels in training dataset:  [0 1 2 3 4 5 6 7 8 9]\n",
      "Frequencies in training dataset:  [67 67 58 71 54 60 62 57 50 54]\n"
     ]
    }
   ],
   "source": [
    "#random permute the data and split into training and test taking the first 600\n",
    "#data samples as training and 4000 samples as test\n",
    "permutation = np.random.permutation(X.shape[0])\n",
    "\n",
    "X = X[permutation]\n",
    "y = y[permutation]\n",
    "\n",
    "m_training = 600\n",
    "m_test = 4000\n",
    "\n",
    "X_train, X_test = X[:m_training], X[m_training:m_training+m_test,:]\n",
    "y_train, y_test = y[:m_training], y[m_training:m_training+m_test]\n",
    "\n",
    "print(X_train.shape, X_test.shape, y_train.shape, y_test.shape)\n",
    "\n",
    "labels, freqs = np.unique(y_train, return_counts=True)\n",
    "print(\"Labels in training dataset: \", labels)\n",
    "print(\"Frequencies in training dataset: \", freqs)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#function for plotting a image and printing the corresponding label\n",
    "def plot_input(X_matrix, labels, index):\n",
    "    print(\"INPUT:\")\n",
    "    plt.imshow(\n",
    "        X_matrix[index].reshape(28,28),#.reshape(24,24),\n",
    "        cmap          = plt.cm.gray_r,\n",
    "        interpolation = \"nearest\"\n",
    "    )\n",
    "    plt.show()\n",
    "    print(\"LABEL: %i\"%labels[index])\n",
    "    return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INPUT:\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LABEL: 6\n",
      "INPUT:\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LABEL: 3\n",
      "INPUT:\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPsAAAD4CAYAAAAq5pAIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAQbklEQVR4nO3de4xUdZrG8ecVexSRBBgaRbrdnsULY0zoIeUlcTPBTBbFRHASZ0VhxDguEwNhIP6xhtVojAnEMD0Zko1Jj4rNxvWSOKxKjAg6CZl/iCVBQNu1WWSlFaEJF7nf+t0/+mAa7PM7TdWpC/6+n6RT3fXU6XotfPp016/qHHN3Afjxu6jWAwCoDsoORIKyA5Gg7EAkKDsQiYureWejR4/2lpaWat5lFE6cOJGadXV1Bbc9duxYMDezYD5mzJhg3tTUFMyRr+3bt2vPnj0D/qOVVXYzu1PSnyUNkfSCuy8J3b6lpUXFYrGcu8QAuru7U7MpU6YEt+3s7Azml1xySTB/8MEHg/nixYtTsyFDhgS3xfkrFAqpWcm/xpvZEEn/IWmqpBsk3W9mN5T6/QBUVjl/s98saau7b3P3E5JekzQ9n7EA5K2cso+TtKPf193JdWcxszlmVjSzYk9PTxl3B6Ac5ZR9oCcBfvDaW3dvd/eCuxcaGxvLuDsA5Sin7N2Smvt93STpm/LGAVAp5ZT9I0nXmtnPzOwnkmZIejufsQDkreSlN3c/ZWbzJK1W39LbS+7+aW6T4XsHDhwI5nPnzk3Ntm3bFty2ra0tmH/22WfBfOnSpcF8+PDhqdkTTzwR3DZrjR/np6x1dnd/V9K7Oc0CoIJ4uSwQCcoORIKyA5Gg7EAkKDsQCcoORKKq72fHwE6fPh3Ms9ajV61alZp1dHQEt505c2YwX7t2bTB/4YUXgnl7e3tqtmDBguC2oTV6nD/27EAkKDsQCcoORIKyA5Gg7EAkKDsQCZbe6sCePXuC+YoVK4L5I488kprNmjWrpJnOyDoUdNbRh0aMGJGaZR25Fvlizw5EgrIDkaDsQCQoOxAJyg5EgrIDkaDsQCRYZ68D3377bTA/cuRIMN+xY0dq1tvbG9z2oovCP+9Dp4OWpKNHjwbzyy67LDVz/8EJhFBB7NmBSFB2IBKUHYgEZQciQdmBSFB2IBKUHYgE6+x1YO/evcH81KlTwfy9995LzaZOnRrcduHChcF869atwfzQoUPBPPQagqxDaCNfZZXdzLZLOijptKRT7l7IYygA+ctjz367u4cPtQKg5vibHYhEuWV3Se+b2cdmNmegG5jZHDMrmlmxp6enzLsDUKpyy36bu0+SNFXSXDP75bk3cPd2dy+4eyHr4IQAKqessrv7N8nlbkkrJd2cx1AA8ldy2c1smJkNP/O5pCmStuQ1GIB8lfNs/BWSVprZme/zX+6evuCLVM3NzcG8oaEhmJ88eTI1e//994PbZuXlGjt2bGrGceOrq+Syu/s2SRNznAVABbH0BkSCsgORoOxAJCg7EAnKDkSCt7jWgdDylCRdfvnlwXzfvn15jpOr0PJasmyLKmHPDkSCsgORoOxAJCg7EAnKDkSCsgORoOxAJFhnrwPDhg0L5jfddFMwD71NtbW1Nbht1qGmN2/eHMxXrVoVzL/88svULOtU1FmvL8D5Yc8ORIKyA5Gg7EAkKDsQCcoORIKyA5Gg7EAkWGevA8eOHQvm3333XTBfvHhxavbYY48Ftz169Ggwf/LJJ4N5loMHD6ZmX3/9dXDb66+/vqz7xtnYswORoOxAJCg7EAnKDkSCsgORoOxAJCg7EAnW2augt7c3mD/wwAPB/I477gjmCxYsSM22bt0a3HbGjBnB/IsvvgjmWfbv35+aLVmyJLjt8uXLy7pvnC1zz25mL5nZbjPb0u+6UWa2xsy6ksuRlR0TQLkG82v8y5LuPOe6xyV94O7XSvog+RpAHcssu7uvk7T3nKunS+pIPu+QdE/OcwHIWalP0F3h7jslKbkck3ZDM5tjZkUzK/b09JR4dwDKVfFn49293d0L7l5obGys9N0BSFFq2XeZ2VhJSi535zcSgEootexvS5qdfD5b0lv5jAOgUszdwzcwe1XSZEmjJe2S9JSk/5b0hqSrJX0l6Tfufu6TeD9QKBS8WCyWOfKFp6urK5hPmDAhmL/1VvhnaejY7E899VRw21qe233EiBHBPOuY9U1NTXmO86NQKBRULBYHPPF95otq3P3+lOhXZU0FoKp4uSwQCcoORIKyA5Gg7EAkKDsQCd7iWgXr168P5llvgb377rvzHKduhN7+KknPPfdcMF+2bFme4/zosWcHIkHZgUhQdiASlB2IBGUHIkHZgUhQdiASrLNXwYYNG8ra3mzAdyx+79Zbb03NLr44/E+c9RqAoUOHBvMDBw4E82HDhqVmp0+fDm77zjvvBPO2trZgnvXfHhv27EAkKDsQCcoORIKyA5Gg7EAkKDsQCcoORIKFyCpoaWkJ5rfffnswnzdvXjCfNm1aarZw4cLgtq2trcF85MjwCXqfeeaZYH748OFgHpJ1mPOsHGdjzw5EgrIDkaDsQCQoOxAJyg5EgrIDkaDsQCRYZ6+C+fPnl5Vn2bNnT2qW9Z7wdevWBfPVq1eXNFMe5s6dG8wbGhqqNMmPQ+ae3cxeMrPdZral33VPm9nXZrYx+birsmMCKNdgfo1/WdKdA1z/J3dvTT7ezXcsAHnLLLu7r5O0twqzAKigcp6gm2dmm5Jf81NfQG1mc8ysaGbFnp6eMu4OQDlKLfvzksZLapW0U9If027o7u3uXnD3QmNjY4l3B6BcJZXd3Xe5+2l375X0F0k35zsWgLyVVHYzG9vvy19L2pJ2WwD1IXOd3cxelTRZ0mgz65b0lKTJZtYqySVtl/T7Cs6IDCtXrkzNmpubg9uOGzcumJd77PXQMe+z/qybOXNmWfeNs2X+S7r7/QNc/WIFZgFQQbxcFogEZQciQdmBSFB2IBKUHYgEb3G9AJw4cSKYv/LKK6nZ7Nmzg9seP348mL/22mvBPMtVV12Vmr355pslb4vzx54diARlByJB2YFIUHYgEpQdiARlByJB2YFIsM5+Afjkk0+C+fr161Oz++67L7jt9OnTg/natWuDeZZJkyalZrfccktZ3xvnhz07EAnKDkSCsgORoOxAJCg7EAnKDkSCsgORYJ09B1u2hA+bv2LFimB+6NChYJ611n3s2LHULOu0x+4ezMs1YcKEin5/DB57diASlB2IBGUHIkHZgUhQdiASlB2IBGUHIsE6+yC9/vrrqdmiRYuC286aNSuYh97zLYXfr56l0uvol156aTC/9957K3r/GLzMPbuZNZvZ38ys08w+NbM/JNePMrM1ZtaVXI6s/LgASjWYX+NPSXrM3X8u6VZJc83sBkmPS/rA3a+V9EHyNYA6lVl2d9/p7huSzw9K6pQ0TtJ0SR3JzTok3VOpIQGU77yeoDOzFkm/kLRe0hXuvlPq+4EgaUzKNnPMrGhmxZ6envKmBVCyQZfdzC6X9KakBe7+3WC3c/d2dy+4e6GxsbGUGQHkYFBlN7MG9RX9FXf/a3L1LjMbm+RjJe2uzIgA8pC59GZmJulFSZ3u3tYvelvSbElLksu3KjJhlezeHf5ZNX/+/NRs8eLFwW0ffvjhkmY6o7u7O5hv2LCh5O/d0NAQzB966KFg/uijjwbz1tbW8x0JFTKYdfbbJP1W0mYz25hct0h9JX/DzH4n6StJv6nMiADykFl2d/+7JEuJf5XvOAAqhZfLApGg7EAkKDsQCcoORIKyA5HgLa6JgwcPBvN9+/alZhMnTsx7nLPMmDEjmG/atCk1u+6668r63uPHjw/mfS/DwIWAPTsQCcoORIKyA5Gg7EAkKDsQCcoORIKyA5FgnT0xdOjQYH7y5MnUbPny5cFts97TPWTIkGDe1NQUzLNOCX2hCj3mg8n37t2bmo0ePTq4bdYhsi9E7NmBSFB2IBKUHYgEZQciQdmBSFB2IBKUHYgE6+yJrDXbkOeffz6YZ62jP/vss8F8+PDh5z1TXrJO+bx///5gvmbNmtTs888/D267atWqYL5jx45gHpqtubk5uO3SpUuD+bRp04J5PWLPDkSCsgORoOxAJCg7EAnKDkSCsgORoOxAJAZzfvZmSSskXSmpV1K7u//ZzJ6W9K+SepKbLnL3dys1aKWVc47z3t7eYL5s2bJg3tHREcyvvvrqYH7q1KnUrKWlJbjtzp07g/lXX30VzA8fPhzMjx8/HsxrpaurK5h/+OGHwfxCXGcfzItqTkl6zN03mNlwSR+b2ZlXSvzJ3cOvPgBQFwZzfvadknYmnx80s05J4yo9GIB8ndff7GbWIukXktYnV80zs01m9pKZjUzZZo6ZFc2s2NPTM9BNAFTBoMtuZpdLelPSAnf/TtLzksZLalXfnv+PA23n7u3uXnD3QmNjYw4jAyjFoMpuZg3qK/or7v5XSXL3Xe5+2t17Jf1F0s2VGxNAuTLLbn2n6XxRUqe7t/W7fmy/m/1a0pb8xwOQl8E8G3+bpN9K2mxmG5PrFkm638xaJbmk7ZJ+X5EJq2TKlCnBvK2tLTV7+eWXg9uGTqksSQcOHAjmmzdvDuYhnZ2dJW9ba1l/9k2YMCGY33jjjalZ1nLm5MmTg/mFaDDPxv9d0kAn4b5g19SBGPEKOiASlB2IBGUHIkHZgUhQdiASlB2IhGUdKjhPhULBi8Vi1e6vWo4cORLMV69eHczfeOONYJ51uOajR4+mZllv3b3mmmuC+fjx44P5lVdeGcwnTpyYmk2aNCm4bdbbc0eNGhXMY1QoFFQsFgdaKmfPDsSCsgORoOxAJCg7EAnKDkSCsgORoOxAJKq6zm5mPZL+r99VoyXtqdoA56deZ6vXuSRmK1Wes/2Duw94IICqlv0Hd25WdPdCzQYIqNfZ6nUuidlKVa3Z+DUeiARlByJR67K31/j+Q+p1tnqdS2K2UlVltpr+zQ6gemq9ZwdQJZQdiERNym5md5rZ/5jZVjN7vBYzpDGz7Wa22cw2mllN33yfnENvt5lt6XfdKDNbY2ZdyeWA59ir0WxPm9nXyWO30czuqtFszWb2NzPrNLNPzewPyfU1fewCc1Xlcav63+xmNkTSF5L+WVK3pI8k3e/un1V1kBRmtl1Swd1r/gIMM/ulpEOSVrj7jcl1z0na6+5Lkh+UI9393+pktqclHar1abyTsxWN7X+acUn3SHpINXzsAnP9i6rwuNViz36zpK3uvs3dT0h6TdL0GsxR99x9naS951w9XVJH8nmH+v5nqbqU2eqCu+909w3J5wclnTnNeE0fu8BcVVGLso+TtKPf192qr/O9u6T3zexjM5tT62EGcIW775T6/ueRNKbG85wr8zTe1XTOacbr5rEr5fTn5apF2Qc6PlY9rf/d5u6TJE2VNDf5dRWDM6jTeFfLAKcZrwulnv68XLUoe7ek5n5fN0n6pgZzDMjdv0kud0taqfo7FfWuM2fQTS5313ie79XTabwHOs246uCxq+Xpz2tR9o8kXWtmPzOzn0iaIentGszxA2Y2LHniRGY2TNIU1d+pqN+WNDv5fLakt2o4y1nq5TTeaacZV40fu5qf/tzdq/4h6S71PSP/v5L+vRYzpMz1j5I+ST4+rfVskl5V3691J9X3G9HvJP1U0geSupLLUXU0239K2ixpk/qKNbZGs/2T+v403CRpY/JxV60fu8BcVXnceLksEAleQQdEgrIDkaDsQCQoOxAJyg5EgrIDkaDsQCT+HzfBCcAq52hsAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LABEL: 8\n",
      "INPUT:\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LABEL: 7\n"
     ]
    }
   ],
   "source": [
    "#let's try the plotting function\n",
    "plot_input(X_train,y_train,5)\n",
    "plot_input(X_test,y_test,50)\n",
    "plot_input(X_test,y_test,500)\n",
    "plot_input(X_test,y_test,700)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## TO DO 1\n",
    "Use a SVM classifier with cross validation to pick a model. Use a 4-fold cross-validation. Let's start with a Linear kernel:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Anay Deshpande\\Anaconda3\\lib\\site-packages\\sklearn\\model_selection\\_search.py:814: DeprecationWarning: The default of the `iid` parameter will change from True to False in version 0.22 and will be removed in 0.24. This will change numeric results when test-set sizes are unequal.\n",
      "  DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RESULTS FOR LINEAR KERNEL\n",
      "Best parameters set found:\n",
      "{'C': 0.01}\n",
      "Score with best parameters:\n",
      "0.7366666666666667\n",
      "\n",
      "All scores on the grid:\n",
      "[0.73666667 0.735      0.735      0.735     ]\n"
     ]
    }
   ],
   "source": [
    "#import SVC\n",
    "from sklearn.svm import SVC\n",
    "#import for Cross-Validation\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "\n",
    "# parameters for linear SVM\n",
    "parameters = {'C': [ 0.01, 0.1, 1, 10]}\n",
    "\n",
    "#run linear SVM\n",
    "linear_SVM = SVC(kernel='linear')\n",
    "linear_SVM_CV = GridSearchCV(linear_SVM, parameters,cv=4)\n",
    "linear_SVM_CV.fit(X_train, y_train)\n",
    "\n",
    "print ('RESULTS FOR LINEAR KERNEL')\n",
    "\n",
    "print(\"Best parameters set found:\")\n",
    "print(linear_SVM_CV.best_params_)\n",
    "\n",
    "print(\"Score with best parameters:\")\n",
    "print(linear_SVM_CV.best_score_)\n",
    "print()\n",
    "print(\"All scores on the grid:\")\n",
    "print(linear_SVM_CV.cv_results_['mean_test_score'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## TO DO 2\n",
    "Pick a model for the Polynomial kernel with degree=2:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Anay Deshpande\\Anaconda3\\lib\\site-packages\\sklearn\\model_selection\\_search.py:814: DeprecationWarning: The default of the `iid` parameter will change from True to False in version 0.22 and will be removed in 0.24. This will change numeric results when test-set sizes are unequal.\n",
      "  DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RESULTS FOR POLY DEGREE=2 KERNEL\n",
      "Best parameters set found:\n",
      "{'C': 0.01, 'gamma': 1.0}\n",
      "Score with best parameters:\n",
      "0.7566666666666667\n",
      "\n",
      "All scores on the grid:\n",
      "[{'C': 0.01, 'gamma': 0.01}, {'C': 0.01, 'gamma': 0.1}, {'C': 0.01, 'gamma': 1.0}, {'C': 0.1, 'gamma': 0.01}, {'C': 0.1, 'gamma': 0.1}, {'C': 0.1, 'gamma': 1.0}, {'C': 1, 'gamma': 0.01}, {'C': 1, 'gamma': 0.1}, {'C': 1, 'gamma': 1.0}]\n",
      "[0.11833333 0.75333333 0.75666667 0.44       0.75666667 0.75666667\n",
      " 0.75333333 0.75666667 0.75666667]\n"
     ]
    }
   ],
   "source": [
    "# parameters for poly with degree 2 kernel\n",
    "parameters = {'C': [0.01, 0.1, 1],'gamma':[0.01,0.1,1.]}\n",
    "\n",
    "#run SVM with poly of degree 2 kernel\n",
    "poly2_SVM = SVC(kernel='poly',degree=2) #,coef0=1) #,gamma=1\n",
    "poly2_SVM_CV = GridSearchCV(poly2_SVM, parameters,cv=4)\n",
    "poly2_SVM_CV.fit(X_train, y_train)\n",
    "\n",
    "print ('RESULTS FOR POLY DEGREE=2 KERNEL')\n",
    "\n",
    "print(\"Best parameters set found:\")\n",
    "print(poly2_SVM_CV.best_params_)\n",
    "\n",
    "print(\"Score with best parameters:\")\n",
    "print(poly2_SVM_CV.best_score_)\n",
    "\n",
    "print(\"\\nAll scores on the grid:\")\n",
    "print(poly2_SVM_CV.cv_results_['params'])\n",
    "print(poly2_SVM_CV.cv_results_['mean_test_score'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## TO DO 3\n",
    "\n",
    "Now let's try a higher degree for the polynomial kernel (e.g., 3rd degree)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Anay Deshpande\\Anaconda3\\lib\\site-packages\\sklearn\\model_selection\\_search.py:814: DeprecationWarning: The default of the `iid` parameter will change from True to False in version 0.22 and will be removed in 0.24. This will change numeric results when test-set sizes are unequal.\n",
      "  DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RESULTS FOR POLY DEGREE= 3  KERNEL\n",
      "Best parameters set found:\n",
      "{'C': 0.01, 'gamma': 1}\n",
      "Score with best parameters:\n",
      "0.6883333333333334\n",
      "\n",
      "All scores on the grid:\n",
      "[0.11833333 0.67666667 0.68833333 0.38       0.68833333 0.68833333\n",
      " 0.67333333 0.68833333 0.68833333]\n"
     ]
    }
   ],
   "source": [
    "# parameters for poly with higher degree kernel\n",
    "parameters = {'C': [0.01, 0.1, 1],'gamma':[0.01,0.1, 1]}\n",
    "\n",
    "#run SVM with poly of higher degree kernel\n",
    "degree = 3\n",
    "poly_SVM = SVC(kernel='poly',degree=degree)\n",
    "poly_SVM_CV = GridSearchCV(poly_SVM, parameters,cv=4)\n",
    "poly_SVM_CV.fit(X_train, y_train)\n",
    "\n",
    "print ('RESULTS FOR POLY DEGREE=', degree, ' KERNEL')\n",
    "\n",
    "print(\"Best parameters set found:\")\n",
    "print(poly_SVM_CV.best_params_)\n",
    "\n",
    "print(\"Score with best parameters:\")\n",
    "print(poly_SVM_CV.best_score_)\n",
    "\n",
    "print(\"\\nAll scores on the grid:\")\n",
    "print(poly_SVM_CV.cv_results_['mean_test_score'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## TO DO 4\n",
    "Pick a model for the Radial Basis Function kernel:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Anay Deshpande\\Anaconda3\\lib\\site-packages\\sklearn\\model_selection\\_search.py:814: DeprecationWarning: The default of the `iid` parameter will change from True to False in version 0.22 and will be removed in 0.24. This will change numeric results when test-set sizes are unequal.\n",
      "  DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RESULTS FOR rbf KERNEL\n",
      "Best parameters set found:\n",
      "{'C': 10, 'gamma': 0.01}\n",
      "Score with best parameters:\n",
      "0.795\n",
      "\n",
      "All scores on the grid:\n",
      "[0.11833333 0.20166667 0.11833333 0.11833333 0.6        0.76666667\n",
      " 0.14666667 0.11833333 0.74833333 0.795      0.155      0.11833333\n",
      " 0.75333333 0.795      0.155      0.11833333]\n"
     ]
    }
   ],
   "source": [
    "# parameters for rbf SVM\n",
    "parameters = {'C': [0.1, 1, 10, 100],'gamma':[0.001, 0.01, 0.1,1]}\n",
    "\n",
    "#run SVM with rbf kernel\n",
    "rbf_SVM = SVC(kernel='rbf')\n",
    "rbf_SVM_CV = GridSearchCV(rbf_SVM, parameters,cv=4)\n",
    "rbf_SVM_CV.fit(X_train, y_train)\n",
    "\n",
    "print ('RESULTS FOR rbf KERNEL')\n",
    "\n",
    "print(\"Best parameters set found:\")\n",
    "print(rbf_SVM_CV.best_params_)\n",
    "\n",
    "print(\"Score with best parameters:\")\n",
    "print(rbf_SVM_CV.best_score_)\n",
    "\n",
    "print(\"\\nAll scores on the grid:\")\n",
    "print(rbf_SVM_CV.cv_results_['mean_test_score'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## TO DO 5\n",
    "What do you observe when using RBF and polynomial kernels on this dataset ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## TO DO 6\n",
    "Report here the best SVM kernel and parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best SVM training error: 0.000000\n",
      "Best SVM test error: 0.180250\n"
     ]
    }
   ],
   "source": [
    "#get training and test error for the best SVM model from CV\n",
    "best_SVM = SVC(kernel='rbf',C=10,gamma=0.01)\n",
    "best_SVM.fit(X_train, y_train)\n",
    "training_error = 1. - best_SVM.score(X_train,y_train)\n",
    "test_error = 1. - best_SVM.score(X_test,y_test)\n",
    "\n",
    "print (\"Best SVM training error: %f\" % training_error)\n",
    "print (\"Best SVM test error: %f\" % test_error)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.e-05 1.e-04 1.e-03 1.e-02 1.e-01 1.e+00 1.e+01 1.e+02]\n"
     ]
    }
   ],
   "source": [
    "#Test with different values of gamma\n",
    "\n",
    "# Set gamma values\n",
    "gamma_values = np.logspace(-5,2,8)\n",
    "print(gamma_values)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Try the SVM with the previously set values of gamma\n",
    "# use rbf kernel and C=1\n",
    "\n",
    "train_acc_list, test_acc_list = [], []\n",
    "for gamma in gamma_values:\n",
    "    rbf_SVM = SVC(kernel='rbf', gamma=gamma, C=1)\n",
    "    rbf_SVM.fit(X_train, y_train)\n",
    "    train_acc_list.append(rbf_SVM.score(X_train, y_train))\n",
    "    test_acc_list.append(rbf_SVM.score(X_test, y_test))\n",
    "\n",
    "# Plot\n",
    "fig, ax = plt.subplots(1,2, figsize=(15,5))\n",
    "\n",
    "ax[0].plot(gamma_values, train_acc_list)\n",
    "ax[0].set_xscale('log')\n",
    "ax[0].set_xlabel('gamma')\n",
    "ax[0].set_ylabel('Train accuracy')\n",
    "ax[0].grid(True)\n",
    "\n",
    "ax[1].plot(gamma_values, test_acc_list)\n",
    "ax[1].set_xscale('log')\n",
    "ax[1].set_xlabel('gamma')\n",
    "ax[1].set_ylabel('Test accuracy')\n",
    "ax[1].grid(True)\n",
    "\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## More data\n",
    "Now let's do the same but using more data points for training.\n",
    "\n",
    "### TO DO 7\n",
    "Choose a new number of data points."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Labels in training dataset:  [0 1 2 3 4 5 6 7 8 9]\n",
      "Frequencies in training dataset:  [209 204 215 193 210 194 165 197 197 216]\n"
     ]
    }
   ],
   "source": [
    "X = X[permutation]\n",
    "y = y[permutation]\n",
    "\n",
    "m_training = 2000 # TODO number of data points, adjust depending on the capabilities of your PC\n",
    "\n",
    "X_train, X_test = X[:m_training], X[m_training:]\n",
    "y_train, y_test = y[:m_training], y[m_training:]\n",
    "\n",
    "labels, freqs = np.unique(y_train, return_counts=True)\n",
    "print(\"Labels in training dataset: \", labels)\n",
    "print(\"Frequencies in training dataset: \", freqs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's try to use SVM with parameters obtained from the best model for $m_{training} =  1500$. Since it may take a long time to run, you can decide to just let it run for some time and stop it if it does not complete. If you decide to do this, report it in the TO DO 9 cell below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best SVM training error: 0.000000\n",
      "Best SVM test error: 0.115879\n"
     ]
    }
   ],
   "source": [
    "#get training and test error for the best SVM model from CV\n",
    "rbf_SVM = SVC(kernel='rbf',C=10,gamma=0.01)\n",
    "rbf_SVM.fit(X_train, y_train)\n",
    "training_error = 1. - rbf_SVM.score(X_train,y_train)\n",
    "test_error = 1. - rbf_SVM.score(X_test,y_test)\n",
    "\n",
    "print (\"Best SVM training error: %f\" % training_error)\n",
    "print (\"Best SVM test error: %f\" % test_error)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just for comparison, let's also use logistic regression (with standard parameters from scikit-learn, i.e. some regularization is included)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Anay Deshpande\\Anaconda3\\lib\\site-packages\\sklearn\\linear_model\\logistic.py:469: FutureWarning: Default multi_class will be changed to 'auto' in 0.22. Specify the multi_class option to silence this warning.\n",
      "  \"this warning.\", FutureWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best logistic regression training error: 0.000000\n",
      "Best logistic regression test error: 0.299724\n"
     ]
    }
   ],
   "source": [
    "from sklearn import linear_model\n",
    "\n",
    "lr = linear_model.LogisticRegression(penalty='l2', C=9999999, solver='newton-cg') # regularization not included\n",
    "lr.fit(X_train, y_train)\n",
    "training_error = 1. - lr.score(X_train,y_train)\n",
    "test_error = 1. - lr.score(X_test,y_test)\n",
    "\n",
    "print (\"Best logistic regression training error: %f\" % training_error)\n",
    "print (\"Best logistic regression test error: %f\" % test_error)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Anay Deshpande\\Anaconda3\\lib\\site-packages\\sklearn\\linear_model\\logistic.py:469: FutureWarning: Default multi_class will be changed to 'auto' in 0.22. Specify the multi_class option to silence this warning.\n",
      "  \"this warning.\", FutureWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best regularized logistic regression training error: 0.008000\n",
      "Best regularized logistic regression test error: 0.254724\n"
     ]
    }
   ],
   "source": [
    "regL2 = linear_model.LogisticRegression(penalty='l2', C=1, solver='newton-cg')\n",
    "regL2.fit(X_train, y_train)\n",
    "training_error = 1. - regL2.score(X_train,y_train)\n",
    "test_error = 1. - regL2.score(X_test,y_test)\n",
    "\n",
    "print (\"Best regularized logistic regression training error: %f\" % training_error)\n",
    "print (\"Best regularized logistic regression test error: %f\" % test_error)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## TO DO 9\n",
    "Compare and discuss:\n",
    "- the results from SVM with m=600 and with m=1500 training data points. If you stopped the SVM, include such aspect in your comparison.\n",
    "- the results of SVM and of Logistic Regression"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## TO DO 10\n",
    "Plot an item of clothing that is missclassified by logistic regression and correctly classified by SVM."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INPUT:\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LABEL: 6\n",
      "Logistic regression prediction:  2\n",
      "SVM prediction:  6\n"
     ]
    }
   ],
   "source": [
    "LR_prediction = lr.predict(X_test)\n",
    "SVM_prediction = rbf_SVM.predict(X_test)\n",
    "i = 0\n",
    "found = False\n",
    "while ( not found & (i<len(y_test))):\n",
    "    if (LR_prediction[i] != y_test[i]) and (SVM_prediction[i] == y_test[i]):\n",
    "        plot_input(X_test, y_test, i)\n",
    "        print(\"Logistic regression prediction: \", LR_prediction[i])\n",
    "        print(\"SVM prediction: \", SVM_prediction[i])\n",
    "        found = True\n",
    "        i += 1\n",
    "    else:\n",
    "        i += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## TO DO 11\n",
    "Plot the confusion matrix for the SVM classifier and for logistic regression.\n",
    "The confusion matrix has one column for each predicted label and one row for each true label. \n",
    "It shows for each class in the corresponding row how many samples belonging to that class gets each possible output label.\n",
    "Notice that the diagonal contains the correctly classified samples, while the other cells correspond to errors.\n",
    "You can obtain it with the sklearn.metrics.confusion_matrix function (see the documentation).\n",
    "Try also to normalize the confusion matrix by the number of samples in each class in order to measure the accuracy on each single class.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Labels and frequencies in test set:  [5791 5796 5785 5807 5790 5806 5835 5803 5803 5784]\n",
      "\n",
      " Confusion matrix SVM  \n",
      " \n",
      " [[5363    8    5   27  157   72    5   77   47   30]\n",
      " [  26 4991  134   38  125   19  169   10   93  191]\n",
      " [   0  113 4809   99  108   34  334   34  169   85]\n",
      " [   8   40  179 5249   93   85   24   39   67   23]\n",
      " [ 160  110   82   20 5033   31   87   27   90  150]\n",
      " [  48   52  134  129   84 5181   36   33   87   22]\n",
      " [  13  103  280   21  159   23 5025  146   44   21]\n",
      " [  46   12   48   35  183   16   53 5313   35   62]\n",
      " [  63  161   93   86   25   42  158    7 5129   39]\n",
      " [  21  135  156   36  123   11   19   28   69 5186]]\n",
      "\n",
      " Confusion matrix SVM (normalized)   \n",
      " \n",
      " [[0.93 0.   0.   0.   0.03 0.01 0.   0.01 0.01 0.01]\n",
      " [0.   0.86 0.02 0.01 0.02 0.   0.03 0.   0.02 0.03]\n",
      " [0.   0.02 0.83 0.02 0.02 0.01 0.06 0.01 0.03 0.01]\n",
      " [0.   0.01 0.03 0.9  0.02 0.01 0.   0.01 0.01 0.  ]\n",
      " [0.03 0.02 0.01 0.   0.87 0.01 0.02 0.   0.02 0.03]\n",
      " [0.01 0.01 0.02 0.02 0.01 0.89 0.01 0.01 0.01 0.  ]\n",
      " [0.   0.02 0.05 0.   0.03 0.   0.86 0.03 0.01 0.  ]\n",
      " [0.01 0.   0.01 0.01 0.03 0.   0.01 0.92 0.01 0.01]\n",
      " [0.01 0.03 0.02 0.01 0.   0.01 0.03 0.   0.88 0.01]\n",
      " [0.   0.02 0.03 0.01 0.02 0.   0.   0.   0.01 0.9 ]]\n",
      "\n",
      " Confusion matrix LR  \n",
      " \n",
      " [[4830   17   55   60  210  214   32  134  112  127]\n",
      " [  42 3815  479   97  322  138  336   35  212  320]\n",
      " [  28  335 3223  157  230  295  662  144  386  325]\n",
      " [  34  107  215 4296  151  458  102  172  186   86]\n",
      " [ 236  282  349  102 3709  117  304  163  125  403]\n",
      " [ 129   89  172  210  124 4591  106  142  178   65]\n",
      " [  86  282  616  103  290  151 3783  202  231   91]\n",
      " [ 160   53  143  129  255  204  164 4376  126  193]\n",
      " [ 113  253  451  169  136  216  303   88 3936  138]\n",
      " [ 124  246  506  108  280  122   88  103  150 4057]]\n",
      "\n",
      " Confusion matrix LR (normalized)   \n",
      " \n",
      " [[0.83 0.   0.01 0.01 0.04 0.04 0.01 0.02 0.02 0.02]\n",
      " [0.01 0.66 0.08 0.02 0.06 0.02 0.06 0.01 0.04 0.06]\n",
      " [0.   0.06 0.56 0.03 0.04 0.05 0.11 0.02 0.07 0.06]\n",
      " [0.01 0.02 0.04 0.74 0.03 0.08 0.02 0.03 0.03 0.01]\n",
      " [0.04 0.05 0.06 0.02 0.64 0.02 0.05 0.03 0.02 0.07]\n",
      " [0.02 0.02 0.03 0.04 0.02 0.79 0.02 0.02 0.03 0.01]\n",
      " [0.01 0.05 0.11 0.02 0.05 0.03 0.65 0.03 0.04 0.02]\n",
      " [0.03 0.01 0.02 0.02 0.04 0.04 0.03 0.75 0.02 0.03]\n",
      " [0.02 0.04 0.08 0.03 0.02 0.04 0.05 0.02 0.68 0.02]\n",
      " [0.02 0.04 0.09 0.02 0.05 0.02 0.02 0.02 0.03 0.7 ]]\n"
     ]
    }
   ],
   "source": [
    "np.set_printoptions(precision=2, suppress=True) # for better aligned printing of confusion matrix use floatmode='fixed'\n",
    "\n",
    "u, counts = np.unique(y_test, return_counts=True)\n",
    "print(\"Labels and frequencies in test set: \", counts)\n",
    "\n",
    "confusion_SVM = skm.confusion_matrix(y_test, SVM_prediction)\n",
    "print(\"\\n Confusion matrix SVM  \\n \\n\", confusion_SVM)\n",
    "print(\"\\n Confusion matrix SVM (normalized)   \\n \\n\", confusion_SVM /counts[:,None] )\n",
    "\n",
    "confusion_LR = skm.confusion_matrix(y_test, LR_prediction)\n",
    "print(\"\\n Confusion matrix LR  \\n \\n\", confusion_LR)\n",
    "print(\"\\n Confusion matrix LR (normalized)   \\n \\n\", confusion_LR /counts[:,None] )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots()\n",
    "\n",
    "plt.imshow(confusion_SVM /counts[:,None], cmap=\"coolwarm\",interpolation='nearest')\n",
    "\n",
    "cm = confusion_SVM /counts[:,None]\n",
    "fmt = '.2f'\n",
    "thresh = cm.max() / 2.\n",
    "for i in range(cm.shape[0]):\n",
    "    for j in range(cm.shape[1]):\n",
    "        ax.text(j, i, format(cm[i, j], fmt),\n",
    "        ha=\"center\", va=\"center\",\n",
    "        color=\"white\" if cm[i, j] > thresh else \"black\")\n",
    "fig.tight_layout()\n",
    "\n",
    "plt.colorbar()  \n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## TO DO 12\n",
    "Have a look at the confusion matrices and comment on the obtained accuracies. Why some classes have lower accuracies and others an higher one ? Make some guesses on the possible causes.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}