KNN_and_NCC_Classifiers_for_MNIST.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5pqslm1iGhEe"
   },
   "source": [
    "# Neural Networks - Deep Learning #\n",
    "## Iordanis Kokkinidis - 3412 ##\n",
    "## *1st Project (Intermediate)* ##\n",
    "\n",
    "\n",
    "\n",
    " *This is the Intermediary project for the Neural Networks - Deep Learning course in the Computer Science Department of the Aristotle University of Thessaloniki*\n",
    "\n",
    " In this project we are going to use SK Learn's Nearest Neighbors and Nearest Centroid classifiers, in order to classify the handwritten digits from the MNIST Dataset.\n",
    " Below, we will talk a little bit about the data, and the classifiers used, while comparing their performance.\n",
    "\n",
    " Going forward, our goal for the first project is to create a Neural Network from scratch (using Python and numPy) to recognize the handwritten digits of the MNIST Dataset and compare its performance to the three classifiers below. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "NeTJCdP0Ip0V"
   },
   "source": [
    "We start by importing some standard libraries that we will need. We import numpy, so that we can use it for storing our data in np.arrays (matrices and vectors). We import pyPlot, that we are going to use for creating our charts. We also import the neighbors library from sklearn, in order to use the `KNeighborsClassifier()` and the `NearestCentroid()` classifiers. Last but not least, we import the mnist dataset from keras.datasets, which holds 60,000 28x28 grayscale images of the 10 digits, along with a test set of 10,000 images."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "fVi2rKtGC1lG"
   },
   "outputs": [
    {
     "ename": "ModuleNotFoundError",
     "evalue": "No module named 'numpy'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[1], line 2\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[39m# We need to run this cell in order for the other cells to run.\u001b[39;00m\n\u001b[1;32m----> 2\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mnumpy\u001b[39;00m \u001b[39mas\u001b[39;00m \u001b[39mnp\u001b[39;00m\n\u001b[0;32m      3\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mmatplotlib\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mpyplot\u001b[39;00m \u001b[39mas\u001b[39;00m \u001b[39mplt\u001b[39;00m\n\u001b[0;32m      4\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39msklearn\u001b[39;00m \u001b[39mimport\u001b[39;00m neighbors\n",
      "\u001b[1;31mModuleNotFoundError\u001b[0m: No module named 'numpy'"
     ]
    }
   ],
   "source": [
    "# We need to run this cell in order for the other cells to run.\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn import neighbors\n",
    "from keras.datasets import mnist \n",
    "import time\n",
    "import random\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "v4lcVWrnKqhB"
   },
   "source": [
    "## Loading the data ##\n",
    "\n",
    "We load the data from the `mnist.dataset`, using `mnist.load_data()` and store each NumPy array in the appropriate NumPy array. For example, we have X_train containing the images of the training set and y_train containing the labels of the training set.\n",
    "\n",
    "We then reshape the X_train and X_test NumPy arrays from (60000, 28, 28) and (10000,  28, 28) to (60000, (28 \\* 28)) and  (10000, (28 \\* 28)) respectively, basically transforming each image's 28 \\* 28 pixel matrix to a a vector.\n",
    "We also keep the original dataset in the X_train_og and X_test_og NumPy arrays, in order to use them later when we want to plot the (28 \\* 28) images."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {
    "id": "W8QbF9_cCsIH"
   },
   "outputs": [],
   "source": [
    "def load_data():\n",
    "  (X_train, y_train), (X_test, y_test) = mnist.load_data()\n",
    "  X_train_og = X_train\n",
    "  X_test_og = X_test\n",
    "  X_train = X_train.reshape(60000, (28*28))\n",
    "  X_test = X_test.reshape(10000, (28*28))\n",
    "  return X_train, y_train, X_test, y_test, X_train_og, X_test_og"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "C1K1VFhwRAMA"
   },
   "source": [
    "#### Loading the data in X_train, y_train, X_test, y_test, X_train_og and X_test_og arrays. ####\n",
    "\n",
    "We use the function defined above to load our data. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "I0FOW4QfQ97r",
    "outputId": "4af03457-147f-4a32-b6f6-acbb033fe41d"
   },
   "outputs": [],
   "source": [
    "X_train, y_train, X_test, y_test, X_train_og, X_test_og = load_data()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1bo82Oa0NXv5"
   },
   "source": [
    "\n",
    "\n",
    "---\n",
    "\n",
    "\n",
    "## K Nearest Neighbors Classifier ## \n",
    "\n",
    "In the function below defined below, we use SKLearn's KNeighborsClassifier to define our knn classifier and return it. This function takes a parameter k, which is the number of neighbors we want to use with our classifier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {
    "id": "0aPNuS-8F6t9"
   },
   "outputs": [],
   "source": [
    "def define_knn(k):\n",
    "  knn = neighbors.KNeighborsClassifier(k)\n",
    "  return knn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "EOhZxos7oIvc"
   },
   "source": [
    "---\n",
    "\n",
    "\n",
    "## Nearest Centroid Classifier ##\n",
    "\n",
    "In the same way as with the KNeighborsClassifier, we define our NearestCentroid classifier and return it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {
    "id": "JYXpwfaqF8VQ"
   },
   "outputs": [],
   "source": [
    "def define_ncc():\n",
    "  ncc = neighbors.NearestCentroid()\n",
    "  return ncc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zQc1BUw1oO_f"
   },
   "source": [
    "---\n",
    "## Fitting the data in a classifier ##\n",
    "\n",
    "This function is used by both classifiers (KNN and NearestCentroid) to fit the classifier's model according to the given training data (from SKLearn's documentation). The function takes as parameters a classifier (one of the two defined above), the training set data, **X** is an array of the image vectors and **y** is an array of the labels. For both the KNN and NearestCentroid classifiers, we use their _fit(X, y)_ method and then we return the classifier that is ready to make predictions on the test set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {
    "id": "0boM1DFGMrMT"
   },
   "outputs": [],
   "source": [
    "def fit_data(classifier, X, y):\n",
    "  classifier.fit(X, y)\n",
    "  return classifier"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "kdIJIuc0n4uP"
   },
   "source": [
    "---\n",
    "\n",
    "### Defining the classifiers and Getting predictions. ###\n",
    "\n",
    "Below we define three functions, each corresponding to one of the classifier's we want to test (_**KNN** with k=1_, _**KNN** with k=3_ and _**NearestCentroid**_ classifiers). Each of these functions takes **X_train** **X_test** and **y_train** arrays as parameters and behaves the same way. First, they define the appropriate classifier (_The first two also have a variable **k**, that is the **number of neighbors** we want to use in the **KNearestNeighbor classifier**_) and then call on the _fit_data( )_ function giving the classifier and training set arrays (X_train, y_train) as parameters.\n",
    "\n",
    "Then, we use the _time.process_time( )_ function to set a start_time variable (and subsequently an end_time) in order to time how long it takes for the classifier to make predictions on the test set of 10,000 images. For that, we use the _[classifier].predict( )_ function (where classifier is one of our classifiers, **knn** or **ncc**) that takes the **X_test** array of image vectors as a parameter (our test set) and performs classification on that given test data (predicts the label that the test set data have). The predictions that the classifier makes are returned and stored in the predictions array, in order to be returned to the main driver progam, along with the delta_time (time elapsed while the classifier was making predictions _[classifier].predict(X_test)_)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {
    "id": "K5R220pL-UII"
   },
   "outputs": [],
   "source": [
    "def knn1_predictions(X_train, X_test, y_train):\n",
    "  k = 1\n",
    "  knn = define_knn(k)\n",
    "  fit_data(knn, X_train, y_train)\n",
    "  start_time = time.process_time()\n",
    "  predictions = knn.predict(X_test)\n",
    "  end_time = time.process_time()\n",
    "  delta_time = (end_time - start_time) * 1000\n",
    "  delta_time = round(delta_time)\n",
    "  print(\"Made predictions with KNN Classifier with k = 1\")\n",
    "  print(\"Time: \" + str(delta_time) + \"ms\")\n",
    "  return predictions, delta_time\n",
    "\n",
    "def knn3_predictions(X_train, X_test, y_train):\n",
    "  k = 3 \n",
    "  knn = define_knn(k)\n",
    "  fit_data(knn, X_train, y_train)\n",
    "  start_time = time.process_time()\n",
    "  predictions = knn.predict(X_test)\n",
    "  end_time = time.process_time()\n",
    "  delta_time = (end_time - start_time) * 1000\n",
    "  delta_time = round(delta_time)\n",
    "  print(\"Made predictions with KNN Classifier with k = 3\")\n",
    "  print(\"Time: \" + str(delta_time) + \"ms\")\n",
    "  return predictions, delta_time\n",
    "\n",
    "def ncc_predictions(X_train, X_test, y_train):\n",
    "  ncc = define_ncc()\n",
    "  fit_data(ncc, X_train, y_train)\n",
    "  start_time = time.process_time()\n",
    "  predictions = ncc.predict(X_test)\n",
    "  end_time = time.process_time()\n",
    "  delta_time = (end_time - start_time) * 1000\n",
    "  delta_time = round(delta_time)\n",
    "  print(\"Made predictions with the NCC Classifier.\")\n",
    "  print(\"Time: \" + str(delta_time) + \"ms\")\n",
    "  return predictions, delta_time\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Hv-Oi8yCntIa"
   },
   "source": [
    "---\n",
    "\n",
    "## Showing Images of our data ##\n",
    "\n",
    "_The function below is used to show an image of our data, given an **index** (which sample we want to show) and the **X** and **Y** NumPy arrays of the data set_. We must use the **X_train_og** and **X_test_og** arrays, since we kept them in dimensions of _(60000, (28 \\* 28))_ and _(10000, (28 \\* 28))_ respectively. We use the _matplotlib library_ in order to plot the images of our data samples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {
    "id": "QlvTD-wro1Lb"
   },
   "outputs": [],
   "source": [
    "def image_show(index, X, Y):\n",
    "  image = X[index]\n",
    "  fig = plt.figure\n",
    "  plt.imshow(image, cmap='gray')\n",
    "  print(\"Showing sample data \" + str(index) + \" with label: \" + str(Y[index]))\n",
    "  plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mqVbz0QxuRI2"
   },
   "source": [
    "##### _Run the code below, to see a random data sample from the training set_ #####"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 282
    },
    "id": "4isQhJkM3Dps",
    "outputId": "c2f94135-60f1-4836-d6e2-ea46ac51389c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Showing sample data 21586 with label: 0\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "index = random.randrange(0,60000)\n",
    "image_show(index, X_train_og, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "85u7wz8HnwEd"
   },
   "source": [
    "---\n",
    "\n",
    "### Printing the predictions ###\n",
    "\n",
    "We have defined a method below, that prints the predictions of a classifier. The function takes as parameters the predictions array, which is the predictions of a classifier we want to print, the X_test_og array, in order to plot the image of the samples if we want, the y_test which is the array that holds the labels of our dataset, and two boolean variables called print_wrong_predictions and print_correct_predictions, so that we can specify what kind of predictions (or both) we want to see. It also takes a number_of_predictions parameter, that specifies how many predictions we want to see. This number must be between 1 and 10,000, although setting it to a large number might not be the optimal choice.\n",
    "\n",
    "In this function, we use a pseudo-random number generator to generate a number between 0 and 10,000, that is the index of the data sample we are going to print, in order to show a number of different predictions each time and not all of them, since that will take some time and the output will not be very readable.\n",
    "\n",
    "When an index is generated, we check if the `predictions[index]` is equal to the `y[index]` in order to determine if the prediction was correct or not. This is not only done so that we can accompany the image of our data sample with the appropriate label (i.e., the prediction was CORRECT!), but also to allow the user to only print correct or wrong predictions if he wishes.\n",
    "\n",
    "*This works better if you run the python file and not the notebook*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {
    "id": "YoXYN6j2xoNp"
   },
   "outputs": [],
   "source": [
    "def print_predictions(predictions, X, y, print_wrong_predictions, print_correct_predictions, number_of_predictions_to_print):\n",
    "  for i in range(0, number_of_predictions_to_print):\n",
    "    index = random.randrange(0,10000)\n",
    "    if((predictions[index] != y[index])):\n",
    "      if(print_wrong_predictions):\n",
    "        image_show(index,X, y)\n",
    "        print(\"Classifier's prediction: \" , predictions[index])\n",
    "        print(\"The prediction was WRONG!\")\n",
    "        print(\"The correct label is: \", y_test[index])\n",
    "        print(\"\\n\")\n",
    "    else:\n",
    "      if(print_correct_predictions):\n",
    "        image_show(index,X, y)\n",
    "        print(\"Classifier's prediction: \" , predictions[index])\n",
    "        print(\"The prediction was CORRECT!\")\n",
    "        print(\"\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "G1Orib1nnyXD"
   },
   "source": [
    "---\n",
    "### Getting the wrong predictions ###\n",
    "\n",
    "The function below is used to get the wrong predictions and the number of wrong predictions that a classifier has made. It takes as parameters the predictions of the classifier and the y (y_test) array, which holds the labels for our test data. We iterate through the predictions array `for i in range(1, 10000)` and check if the `predictions[i]` is not equal to the `y[i]`. If yes, then the `wrong_predictions_total`is incremented and that prediction is put in the wrong_predictions array. We finally return the `wrong_predictions` array and the `wrong_predictions_total`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {
    "id": "orApx0SN7hcO"
   },
   "outputs": [],
   "source": [
    "def get_wrong_predictions(predictions, y):\n",
    "  wrong_predictions = []\n",
    "  wrong_predictions_total = 0\n",
    "  for i in range(1, 10000):\n",
    "    if((predictions[i] != y[i])):\n",
    "      wrong_predictions_total += 1\n",
    "      wrong_predictions.append(i)\n",
    "  return wrong_predictions, wrong_predictions_total"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "BT0nDwiWn1vo"
   },
   "source": [
    "### Getting a classifier's accuracy ###\n",
    "\n",
    "This function is used to calculate the accuracy of a classifier's predictions. It simply takes as a parameter the `wrong_predictions` number of a classifier and return the percentage of correct predictions.\n",
    "Since the test set contains 10,000 data samples, we divide the number of `wrong_predictions` by that and to get error. Then, we subtract that error from 1, to get the accuracy, that we multiply by a hundred to present it as a percentage (%).   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {
    "id": "Hk_xUD-JYePw"
   },
   "outputs": [],
   "source": [
    "def get_accuracy(wrong_predictions):\n",
    "  return ((1-(wrong_predictions/10000)) * 100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0nemljFagN5C"
   },
   "source": [
    "---\n",
    "\n",
    "## Driver Program ##\n",
    "##### The cell below is the main part of the program that loads the data on the three classifiers and for each one gets the predictions, accuracy, time, wrong predictions and can even call a function to print the correct and/or wrong predictions #####\n",
    "\n",
    "We want to test each classifier on the MNIST dataset that we loaded above.\n",
    "\n",
    "We set the print_wrong_predictions and print_correct_predictions for each classifier block of code, depending on what prefferences we have on the output. For example if we want to see the wrong predictions of the NearestCentroid classifier, but not of the KNearestNeighbor classifiers. ***Feel free to change those variables however you see fit.***\n",
    "\n",
    "Then for each classifier, we get the predictions and the time it took to make them by using the appropriate function (those that were defined above). We also get the wrong predictions for each classifier, by using the `get_wrong_predictions()` funciton. Finally, we get the accuracy for each classifier, using the `get_accuracy()` method.\n",
    "We have all the data we need from the classification process and we call on the `print_predictions()` method to print the predictions of each classifier, as explained above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "id": "Ujeb2P6z9bIS",
    "outputId": "6f51fa97-2576-4a0c-8471-c3a64bcf1069"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Made predictions with KNN Classifier with k = 1\n",
      "Time: 100328ms\n",
      "309 wrong predictions out of 10,000 predictions\n",
      "Accuracy: 96.91%\n",
      "\n",
      "\n",
      "\n",
      "Made predictions with KNN Classifier with k = 3\n",
      "Time: 102625ms\n",
      "295 wrong predictions out of 10,000 predictions\n",
      "Accuracy: 97.05%\n",
      "\n",
      "\n",
      "\n",
      "Made predictions with the NCC Classifier.\n",
      "Time: 203ms\n",
      "1797 wrong predictions out of 10,000 predictions\n",
      "Accuracy: 82.03%\n",
      "\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print_wrong_predictions = False\n",
    "print_correct_predictions = False\n",
    "number_of_predictions_to_print = 50\n",
    "\n",
    "predictions, time1 = knn1_predictions(X_train, X_test, y_train)\n",
    "wrong_predictions, wrong_predictions_total = get_wrong_predictions(predictions, y_test)\n",
    "print(str(wrong_predictions_total) + \" wrong predictions out of 10,000 predictions\")  \n",
    "accuracy = get_accuracy(wrong_predictions_total)\n",
    "print(\"Accuracy: \" + str(accuracy) + \"%\\n\")\n",
    "# print(\"Printing prediction's of KNearest Neighbor Classifier with k = 1\")\n",
    "print_predictions(predictions, X_test_og, y_test, print_wrong_predictions, print_correct_predictions, number_of_predictions_to_print)\n",
    "print(\"\\n\")\n",
    "\n",
    "print_wrong_predictions = False\n",
    "print_correct_predictions = False\n",
    "number_of_predictions_to_print = 50\n",
    "\n",
    "predictions2, time2 = knn3_predictions(X_train, X_test, y_train)\n",
    "wrong_predictions2, wrong_predictions_total2 = get_wrong_predictions(predictions2, y_test)\n",
    "print(str(wrong_predictions_total2) + \" wrong predictions out of 10,000 predictions\")\n",
    "accuracy2 = get_accuracy(wrong_predictions_total2)\n",
    "print(\"Accuracy: \" + str(accuracy2) + \"%\\n\")\n",
    "# print(\"Printing prediction's of KNearest Neighbor Classifier with k = 3\")\n",
    "print_predictions(predictions2, X_test_og, y_test, print_wrong_predictions, print_correct_predictions, number_of_predictions_to_print)\n",
    "print(\"\\n\")\n",
    "\n",
    "print_wrong_predictions = False\n",
    "print_correct_predictions = False\n",
    "number_of_predictions_to_print = 50\n",
    "\n",
    "predictions3, time3 = ncc_predictions(X_train, X_test, y_train)\n",
    "wrong_predictions3, wrong_predictions_total3 = get_wrong_predictions(predictions3, y_test)\n",
    "print(str(wrong_predictions_total3) + \" wrong predictions out of 10,000 predictions\")\n",
    "accuracy3 = get_accuracy(wrong_predictions_total3)\n",
    "print(\"Accuracy: \" + str(accuracy3) + \"%\\n\")\n",
    "# print(\"Printing prediction's of Nearest Centroid Classifier\")\n",
    "print_predictions(predictions3, X_test_og, y_test, print_wrong_predictions, print_correct_predictions, number_of_predictions_to_print)\n",
    "print(\"\\n\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "kgleLUrV3N7x"
   },
   "source": [
    "## Run the code cell below to get the charts comparing the accuracy of the two KNN classifiers. ## "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 656
    },
    "id": "7l3udSC_F_8C",
    "outputId": "c9876ede-cc4f-4f71-f947-a89d6206528a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Results\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x1000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "X = [1, 3]\n",
    "scores = [accuracy,accuracy2]\n",
    "bar_colors = ['tab:red', 'tab:blue']\n",
    "plt.figure(1)\n",
    "plt.figure(figsize = (15,10))\n",
    "plt.xlabel(\"Classifiers\")\n",
    "plt.ylabel(\"Accuracy\")\n",
    "plt.title('KNN Classification of the MNIST dataset with 1 and 3 neighbors')\n",
    "plt.ylim(90,100)\n",
    "plt.xlim(0,4)\n",
    "plt.yticks([90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100])\n",
    "plt.xticks([])\n",
    "plt.bar(X, scores, color=bar_colors, label=['k = 1', 'k = 3'])\n",
    "plt.annotate(\"\" + str(scores[0]) + \"%\", xy = (X[0],scores[0]), ha='center', va='bottom')\n",
    "plt.annotate(\"\" + str(scores[1]) + \"%\", xy = (X[1],scores[1]), ha='center', va='bottom')\n",
    "print(\"Results\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Run the code cell below to get the charts comparing the accuracy of the NCC classifier and the two KNN classifiers. ## "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 910
    },
    "id": "JoQpNp3QZinF",
    "outputId": "78a25cce-2fcd-4311-f647-157e2991aded"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x1000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "X2 = [1, 3, 5]\n",
    "scores2 = [accuracy3, accuracy, accuracy2]\n",
    "bar_colors = ['tab:red', 'tab:blue', 'tab:green']\n",
    "plt.figure(figsize = (15,10))\n",
    "plt.xlabel(\"NCC vs KNN\")\n",
    "plt.ylabel(\"Accuracy\")\n",
    "plt.title('Comparing the Accuracy of the Nearest Centroid Classifier with the K Nearest Neighbor Classifier (with k=1 and k=3)')\n",
    "plt.ylim(50,100)\n",
    "plt.xlim(0,6)\n",
    "plt.yticks(range(50, 100))\n",
    "plt.xticks([])\n",
    "plt.bar(X2, scores2, color=bar_colors, label=['Nearest Centroid Classifier', 'KNN Classifier with k=1', 'KNN Classifier with k=3'])\n",
    "plt.annotate(\"\" + str(scores2[0]) + \"%\", xy = (X2[0],scores2[0]), ha='center', va='bottom')\n",
    "plt.annotate(\"\" + str(scores2[1]) + \"%\", xy = (X2[1],scores2[1]), ha='center', va='bottom')\n",
    "plt.annotate(\"\" + str(scores2[2]) + \"%\", xy = (X2[2],scores2[2]), ha='center', va='bottom')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "JLlP0NwENcXw"
   },
   "source": [
    "## Run the code cell below to get the chart comparing the time for training each classifier. ## "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 298
    },
    "id": "0GdnZPtZSwoc",
    "outputId": "c1b60063-6969-4c47-8548-4ac4faddd1b7"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[266, 105109, 104375]\n",
      "105109\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x1000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "X2 = [1, 3, 5]\n",
    "times = [time3, time1, time2]\n",
    "print(times) \n",
    "print(np.max(times))\n",
    "bar_colors = ['tab:red', 'tab:blue', 'tab:green']\n",
    "plt.figure(figsize = (15,10))\n",
    "plt.xlabel(\"Classifier\")\n",
    "plt.ylabel(\"Accuracy\")\n",
    "plt.title('Comparing the Time for training of the Nearest Centroid Classifier with the K Nearest Neighbor Classifier (with k=1 and k=3)')\n",
    "plt.ylim(0, np.max(times) + 10000)\n",
    "plt.xlim(0,6)\n",
    "plt.yticks(range(0,78000, 5000))\n",
    "plt.xticks([])\n",
    "plt.bar(X2, times, color=bar_colors, label=['Nearest Centroid Classifier', 'KNN Classifier with k=1', 'KNN Classifier with k=3'])\n",
    "plt.annotate(\"\" + str(times[0]) + \" ms\", xy = (X2[0],times[0]), ha='center', va='bottom')\n",
    "plt.annotate(\"\" + str(times[1]) + \" ms\", xy = (X2[1],times[1]), ha='center', va='bottom')\n",
    "plt.annotate(\"\" + str(times[2]) + \" ms\", xy = (X2[2],times[2]), ha='center', va='bottom')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "provenance": []
  },
  "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.11.2"
  },
  "vscode": {
   "interpreter": {
    "hash": "b8fe202ecd282fb304adbb9f30823ea56e79259c7376dc5497738e64d69ef834"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}