06.05.Image_classification_MCQ_student_version-4473.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"center\" style=\" font-size: 80%; text-align: center; margin: 0 auto\">\n",
    "<img src=\"https://raw.githubusercontent.com/Explore-AI/Pictures/master/Python-Notebook-Banners/Code_challenge.png\"  style=\"display: block; margin-left: auto; margin-right: auto;\";/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Image classification MCQ \n",
    "© ExploreAI Academy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The versatile machine learning techniques you have been learning will enable you to process complex and different data at a faster pace.  \n",
    "\n",
    "So far you have performed classification on both tabular  ([iris dataset](https://scikit-learn.org/stable/auto_examples/datasets/plot_iris_dataset.html)) and textual data ([the mbti dataset](https://www.kaggle.com/datasnaek/mbti-type)). In this notebook, you will apply the machine learning techniques you have learned for image classification. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Imports\n",
    "\n",
    "Let's go ahead and load our libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import gzip # This is used in extracting the images\n",
    "\n",
    "import matplotlib.pyplot as plt # In order to plot the images to see what we are dealing with\n",
    "from sklearn.ensemble import RandomForestClassifier # You'll be using Random Forest to classify the images\n",
    "from sklearn.metrics import accuracy_score # Sklearn's way of measuring accuracy\n",
    "from sklearn.metrics import classification_report "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "# The data\n",
    "\n",
    "The dataset we will be using is called `MNIST`. This is a large collection of hand-drawn digits `0 to 9` and is a good dataset to learn image classification on as it requires little to no preprocessing.\n",
    "\n",
    "The dataset can be downloaded from [The MNIST Database](https://web.archive.org/web/20220331130319/https://yann.lecun.com/exdb/mnist/). Download all four files. These files are the images and their respective labels (normally, we're required to split the x (image data / characteristics) and y (labels) out during preprocessing, but this has already been done for us). The dataset has also already been split into a train and a test set.\n",
    "\n",
    "Once you've downloaded the data, make sure that the data are in the same folder as this Jupyter notebook. If you've managed to do all that, we can now begin! \n",
    "\n",
    "By default, the MNIST files are compressed in the gzip format. The following two functions will extract the data for you. ** **Don't change this code.** **"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def extract_data(filename, num_images, IMAGE_WIDTH):\n",
    "    \"\"\"Extract the images into a 4D tensor [image index, y, x, channels].\"\"\"\n",
    "    with gzip.open(filename) as bytestream:\n",
    "        bytestream.read(16)\n",
    "        buf = bytestream.read(IMAGE_WIDTH * IMAGE_WIDTH * num_images)\n",
    "        data = np.frombuffer(buf, dtype=np.uint8).astype(np.float32)\n",
    "        data = data.reshape(num_images, IMAGE_WIDTH*IMAGE_WIDTH)\n",
    "        return data\n",
    "\n",
    "def extract_labels(filename, num_images):\n",
    "    \"\"\"Extract the labels into a vector of int64 label IDs.\"\"\"\n",
    "    with gzip.open(filename) as bytestream:\n",
    "        bytestream.read(8)\n",
    "        buf = bytestream.read(1 * num_images)\n",
    "        labels = np.frombuffer(buf, dtype=np.uint8).astype(np.int64)\n",
    "    return labels"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Challenge 1: Extracting the data\n",
    "\n",
    "The MNIST dataset consists of 60,000 training images and 10,000 testing images. This is a lot of data! Let's not extract all of that right now. Create a function `get_data` that uses the above functions to extract a certain number of images and their labels from the gzip files.\n",
    "\n",
    "The function will take as input two integer values, the number of train and test images to be extracted. Let's extract `5000` train images and `1000` test images. The function then returns four variables in the form of `(X_train, y_train), (X_test, y_test)`, where `(X_train, y_train)` are the extracted images and labels of the training set, and `(X-test, y_test)` are the extracted images and labels of the testing set. (Hint – you'll have to use the functions provided more than once.) \n",
    "\n",
    "Image pixel values range from 0 to 255. We need to normalise the image pixels so that they are in the range 0 to 1.\n",
    "\n",
    "_**Function specifications:**_\n",
    "* Should take two integers as input, one representing the number of training images and the other the number of testing images.\n",
    "* Should return two `tuples` of the form `(X_train, y_train), (X_test, y_test)`.\n",
    "\n",
    "_**Note**_ that the size of the MNIST images is 28x28.\n",
    "\n",
    "Usually when setting up your dataset, it is a good idea to randomly shuffle your data in case your data are ordered. Think of this as shuffling a pack of cards. Here, however, we aren't going to shuffle the data so that all our answers are the same."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "### START FUNCTION\n",
    "def get_data(num_train_images,num_test_images):\n",
    "    X_train = extract_data('train-images-idx3-ubyte.gz', num_train_images, 28)\n",
    "    y_train = extract_labels('train-labels-idx1-ubyte.gz', num_train_images)\n",
    "    X_train /= 255.0\n",
    "    \n",
    "    X_test = extract_data('t10k-images-idx3-ubyte.gz', num_test_images, 28)\n",
    "    y_test = extract_labels('t10k-labels-idx1-ubyte.gz', num_test_images)\n",
    "    X_test /= 255.0\n",
    "    return (X_train, y_train), (X_test, y_test)\n",
    "\n",
    "### END FUNCTION"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotting the data\n",
    "\n",
    "Let's see what this data looks like! Right now the images are \"flattened\" into a 1-D array of length 784. In order to plot the image we first need to reshape it to the correct size of 28x28. We'll print out the respective label to make sure we are plotting the right number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Label:  1\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "(X_train, y_train), (X_test, y_test) = get_data(5000, 1000)\n",
    "\n",
    "image_index = 8 ## Change me to view different images\n",
    "\n",
    "print(\"Label: \", y_train[image_index])\n",
    "reshaped_image = X_train[image_index].reshape((28, 28))\n",
    "\n",
    "plt.imshow(reshaped_image, cmap='gray')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_test[50]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Challenge 2: Training the model\n",
    "\n",
    "Now that we have formatted our data, we can fit a model using sklearn's `RandomForestClassifier` class with `20 estimators` and its `random_state` set to `42`. We'll write a function that will take as input the image and label variables that we created previously, and return a trained model.\n",
    "\n",
    "_**Function specifications:**_\n",
    "* Should take two NumPy `arrays` as input in the form `(X_train, y_train)`.\n",
    "* Should return an sklearn `RandomForestClassifier` model which has a random state of 42 and number of estimators 20.\n",
    "* The returned model should be fitted to the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "### START FUNCTION\n",
    "def train_model(X_train, y_train):\n",
    "    model = RandomForestClassifier(n_estimators=25, random_state=42)\n",
    "    model.fit(X_train, y_train)\n",
    "    return model\n",
    "\n",
    "### END FUNCTION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "clf = train_model(X_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Challenge 3: Testing the model\n",
    "\n",
    "Now that you have trained your model, let's see how well it does on the test set. Write a function which returns the accuracy of our trained model when tested with the test set.\n",
    "\n",
    "_**Function specifications:**_\n",
    "* Should take the fitted model `clf` and two NumPy arrays `X_test, y_test` as input.\n",
    "* Should return a `float` of the accuracy of the model. This number should be between zero and one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "### START FUNCTION\n",
    "def calculate_accuracy(clf, X_test, y_test):\n",
    "    y_pred = clf.predict(X_test)\n",
    "    return accuracy_score(y_test, y_pred)\n",
    "\n",
    "### END FUNCTION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9\n"
     ]
    }
   ],
   "source": [
    "print(calculate_accuracy(clf,X_test,y_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Classification reports give us more information on where our model is going wrong – looking specifically at the performance caused by Type I and II errors. Write a function that returns the classification report of your test set.\n",
    "\n",
    "_**Function specifications:**_\n",
    "* Should take the fitted model `clf` and two NumPy arrays `X_test, y_test` as input.\n",
    "* Should return a classification report."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "### START FUNCTION\n",
    "def get_class_report(clf, X_test, y_test):\n",
    "    y_pred = clf.predict(X_test)\n",
    "    return classification_report(y_test, y_pred)\n",
    "\n",
    "### END FUNCTION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.93      0.99      0.96        85\n",
      "           1       1.00      0.98      0.99       126\n",
      "           2       0.88      0.88      0.88       116\n",
      "           3       0.88      0.85      0.87       107\n",
      "           4       0.88      0.90      0.89       110\n",
      "           5       0.88      0.91      0.89        87\n",
      "           6       0.93      0.92      0.92        87\n",
      "           7       0.87      0.87      0.87        99\n",
      "           8       0.91      0.81      0.86        89\n",
      "           9       0.83      0.88      0.86        94\n",
      "\n",
      "    accuracy                           0.90      1000\n",
      "   macro avg       0.90      0.90      0.90      1000\n",
      "weighted avg       0.90      0.90      0.90      1000\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(get_class_report(clf,X_test,y_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotting the results\n",
    "\n",
    "Let's actually see if our model has trained correctly. To do so, plot some of the images with their predicted labels. Since we don't have the predictions stored in our notebook's memory, we need to call the predict function here first."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicted Label:  5\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "preds = clf.predict(X_test)\n",
    "\n",
    "image_index = 15 ## Change me to see other predictions\n",
    "\n",
    "print(\"Predicted Label: \",preds[image_index])\n",
    "plt.imshow(X_test[image_index].reshape((28, 28)), cmap='gray')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since we didn't use all the data in the beginning, there is a chance our performance can improve. Go change the amount of data we use to see how it affects the accuracy of your model."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  \n",
    "\n",
    "<div align=\"center\" style=\" font-size: 80%; text-align: center; margin: 0 auto\">\n",
    "<img src=\"https://raw.githubusercontent.com/Explore-AI/Pictures/master/ExploreAI_logos/EAI_Blue_Dark.png\"  style=\"width:200px\";/>\n",
    "</div>"
   ]
  }
 ],
 "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.12.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}