MATTHEW_PURVIS_07_AIT_CNN_CIFAR10_exercise.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "anaconda-cloud": {},
    "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.6.6"
    },
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Matthew-Z-Purvis/InfoChallenge2023/blob/main/MATTHEW_PURVIS_07_AIT_CNN_CIFAR10_exercise.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cW-EyI5Lxpqi"
      },
      "source": [
        "# Copyright\n",
        "\n",
        "<PRE>\n",
        "Copyright (c) 2024 Bálint Gyires-Tóth - All Rights Reserved\n",
        "You may use and modify this code for research and development purpuses.\n",
        "Using this code for educational purposes (self-paced or instructor led) without the permission of the author is prohibited.\n",
        "</PRE>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Convolutional Neural Network exercise\n",
        "\n",
        "In this notebook, you will build a convolutional neural network, which offers superior results over the previous MLP solution. Additionally, you will perform a more detailed evaluation."
      ],
      "metadata": {
        "id": "3EX4cCa4WKJu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# imports\n",
        "from tensorflow.keras.datasets import cifar10\n",
        "from tensorflow.keras.utils import to_categorical\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from tensorflow.keras.models import Sequential\n",
        "from tensorflow.keras.layers import Dense, Conv2D, MaxPool2D, Flatten, Dropout, BatchNormalization\n",
        "from tensorflow.keras.initializers import HeNormal\n",
        "from tensorflow.keras.callbacks import EarlyStopping"
      ],
      "metadata": {
        "id": "GdCMhy4HA2qd"
      },
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 1. Data\n",
        "The dataset we will use is the well-known CIFAR10 (Canadian Institute For Advanced Research). Explore the details on the Keras website first: https://keras.io/api/datasets/cifar10/\n",
        "\n",
        "There isn't much difference between the data preprocessing part and the one we did before. The only difference is that we don't have to reshape images into vectors, but we are working with a 4 dimensional data structure, where the dimensions are: batch, X, Y, and color channels.\n",
        "\n",
        "In the event that anything is not clear regarding the data preparation part, please check the previous CIFAR10 notebook."
      ],
      "metadata": {
        "id": "yY9fztIeWIKt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "(X_train, Y_train), (X_test, Y_test) = cifar10.load_data()"
      ],
      "metadata": {
        "id": "bez7q0eiWQCK",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6db84c20-8c9d-4f1e-c6a3-905d6b520123"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading data from https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz\n",
            "170498071/170498071 [==============================] - 4s 0us/step\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# it is in int8 format, the neural network requires float32\n",
        "X_train = X_train.astype(\"float32\")\n",
        "X_test = X_test.astype(\"float32\")"
      ],
      "metadata": {
        "id": "vukOcBM0XzSj"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "train_ratio  = 0.8\n",
        "train_length = X_train.shape[0]\n",
        "train_split  = int(train_ratio*train_length)\n",
        "X_valid, Y_valid = X_train[train_split:], Y_train[train_split:]\n",
        "X_train, Y_train = X_train[:train_split], Y_train[:train_split]"
      ],
      "metadata": {
        "id": "mRwuWxxIxLgN"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "mean = X_train.mean(axis=0)\n",
        "std  = X_train.std(axis=0)\n",
        "\n",
        "X_train = (X_train-mean)/std\n",
        "X_valid = (X_valid-mean)/std\n",
        "X_test  = (X_test-mean)/std"
      ],
      "metadata": {
        "id": "2ESLP1EIyB2J"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "nb_classes = len(np.unique(Y_train))\n",
        "Y_train = to_categorical(Y_train, nb_classes)\n",
        "Y_valid = to_categorical(Y_valid, nb_classes)\n",
        "Y_test  = to_categorical(Y_test, nb_classes)"
      ],
      "metadata": {
        "id": "xwZ4OJ6I8lba"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Shapes of the training, validation and test input data:\", X_train.shape, X_valid.shape, X_test.shape)\n",
        "print(\"Shapes of the training, validation and test output data:\", Y_train.shape, Y_valid.shape, Y_test.shape)\n",
        "print(\"Mean values of the training, validation and test input data:\", X_train.mean(), X_valid.mean(), X_test.mean())\n",
        "print(\"Standard deviation of the training, validation and test input data:\", X_train.std(), X_valid.std(), X_test.std())"
      ],
      "metadata": {
        "id": "O_jdJVcvX0vi",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "78f9f446-a76a-4880-b2bb-506338d1a9ca"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Shapes of the training, validation and test input data: (40000, 32, 32, 3) (10000, 32, 32, 3) (10000, 32, 32, 3)\n",
            "Shapes of the training, validation and test output data: (40000, 10) (10000, 10) (10000, 10)\n",
            "Mean values of the training, validation and test input data: 2.2788842e-09 0.0023437198 0.013331206\n",
            "Standard deviation of the training, validation and test input data: 1.0000023 0.9965626 0.99783075\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cJ14oyZExpqj"
      },
      "source": [
        "# 2. Exercise: training"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Create and train a convolutional neural network with the following requirements:\n",
        "* apply early stopping with patience=5 and monitor the validation accuracy, don't forget to load back the best weights after early stopping\n",
        "* the number of trainable parameters is lower than 200.000\n",
        "* the validation accuracy must be higher than 72%\n",
        "\n",
        "Hints:\n",
        "* you can always inspect the number of trainable parameters per layer with model.summary()\n",
        "* usually the most trainable parameters are between the last convolutional layer and the next dense layer -- so you should have a reasonable output size at the last convolutional layer\n",
        "* regularization helps (e.g. DropOut and/or BatchNormalization)\n",
        "* use the right activation function at the output layer and the corresponding loss function\n",
        "* for the chosen activation functions, please use the appropriate initialization method\n",
        "* you can match the dimension of the last conv/pooling layer to the next dense layer with e.g. Flatten()\n",
        "* ADAM optimizer is a reasonable choice\n",
        "* don't forget to turn on GPU support in Colab, otherwise, it would be quite slow to train the networks\n",
        "\n"
      ],
      "metadata": {
        "id": "j1tGVPdD-pp3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from tensorflow.keras.callbacks import EarlyStopping\n",
        "es = EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=5)\n"
      ],
      "metadata": {
        "id": "5dBQxJHIHrbd"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from tensorflow.keras.models import Sequential\n",
        "from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense\n",
        "\n",
        "# Add model layers\n",
        "model = Sequential()\n",
        "model.add(Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)))\n",
        "model.add(MaxPooling2D((2, 2)))\n",
        "model.add(Conv2D(64, (3, 3), activation='relu'))\n",
        "model.add(MaxPooling2D((2, 2)))\n",
        "model.add(Flatten())\n",
        "model.add(Dense(64, activation='relu'))\n",
        "model.add(Dense(10, activation='softmax'))\n",
        "\n",
        "# Compile the model with categorical_crossentropy for one-hot encoded labels\n",
        "model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])\n"
      ],
      "metadata": {
        "id": "PuxHOqLt-3Nd"
      },
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model.summary()"
      ],
      "metadata": {
        "id": "5eomQw8uE9Ix",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b1f26d5d-48cd-4fcd-ed29-195e8b5f682f"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " conv2d (Conv2D)             (None, 30, 30, 32)        896       \n",
            "                                                                 \n",
            " max_pooling2d (MaxPooling2  (None, 15, 15, 32)        0         \n",
            " D)                                                              \n",
            "                                                                 \n",
            " conv2d_1 (Conv2D)           (None, 13, 13, 64)        18496     \n",
            "                                                                 \n",
            " max_pooling2d_1 (MaxPoolin  (None, 6, 6, 64)          0         \n",
            " g2D)                                                            \n",
            "                                                                 \n",
            " flatten (Flatten)           (None, 2304)              0         \n",
            "                                                                 \n",
            " dense (Dense)               (None, 64)                147520    \n",
            "                                                                 \n",
            " dense_1 (Dense)             (None, 10)                650       \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 167562 (654.54 KB)\n",
            "Trainable params: 167562 (654.54 KB)\n",
            "Non-trainable params: 0 (0.00 Byte)\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Please, check the number of trainable paramers:"
      ],
      "metadata": {
        "id": "8tIbIIeTEI41"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"#trainable parameters:\",model.count_params())"
      ],
      "metadata": {
        "id": "xdBAG7EJETlX",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "10eec5bf-79f7-467a-cd50-5ac2af2ed9f6"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "#trainable parameters: 167562\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "network_history = model.fit(X_train, Y_train, epochs=2000,\n",
        "                            validation_data=(X_valid, Y_valid), callbacks=[es])\n"
      ],
      "metadata": {
        "id": "u8tFNCNVHyt9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b3d79771-5442-41ee-c60c-bf9dea1fde3d"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/2000\n",
            "1250/1250 [==============================] - 13s 5ms/step - loss: 1.3645 - accuracy: 0.5129 - val_loss: 1.1190 - val_accuracy: 0.6144\n",
            "Epoch 2/2000\n",
            "1250/1250 [==============================] - 6s 5ms/step - loss: 0.9986 - accuracy: 0.6530 - val_loss: 0.9976 - val_accuracy: 0.6605\n",
            "Epoch 3/2000\n",
            "1250/1250 [==============================] - 6s 4ms/step - loss: 0.8591 - accuracy: 0.7041 - val_loss: 0.9380 - val_accuracy: 0.6763\n",
            "Epoch 4/2000\n",
            "1250/1250 [==============================] - 5s 4ms/step - loss: 0.7622 - accuracy: 0.7367 - val_loss: 0.8959 - val_accuracy: 0.6959\n",
            "Epoch 5/2000\n",
            "1250/1250 [==============================] - 7s 5ms/step - loss: 0.6738 - accuracy: 0.7663 - val_loss: 0.8824 - val_accuracy: 0.7020\n",
            "Epoch 6/2000\n",
            "1250/1250 [==============================] - 5s 4ms/step - loss: 0.6032 - accuracy: 0.7878 - val_loss: 0.9408 - val_accuracy: 0.6974\n",
            "Epoch 7/2000\n",
            "1250/1250 [==============================] - 6s 5ms/step - loss: 0.5353 - accuracy: 0.8122 - val_loss: 0.9618 - val_accuracy: 0.6924\n",
            "Epoch 8/2000\n",
            "1250/1250 [==============================] - 5s 4ms/step - loss: 0.4754 - accuracy: 0.8334 - val_loss: 0.9603 - val_accuracy: 0.7055\n",
            "Epoch 9/2000\n",
            "1250/1250 [==============================] - 6s 5ms/step - loss: 0.4175 - accuracy: 0.8519 - val_loss: 1.0052 - val_accuracy: 0.7001\n",
            "Epoch 10/2000\n",
            "1250/1250 [==============================] - 5s 4ms/step - loss: 0.3702 - accuracy: 0.8705 - val_loss: 1.1589 - val_accuracy: 0.6854\n",
            "Epoch 10: early stopping\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 3. Exercise: evaluation on test data\n",
        "You will evaluate the classification of the test data using the common metrics and the confusion matrix in this section.\n",
        "\n",
        "\n",
        "As a first stes, let's run the predictions and convert the predicted softmax outputs to dense labels. The one-hot encoded labels are also converted back to dense labels, as they are required for the evaluation functions."
      ],
      "metadata": {
        "id": "2FtKp-a2-A9m"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "probas = model.predict(X_test)\n",
        "preds  = np.argmax(probas,axis=1)\n",
        "Y_test_dense = np.argmax(Y_test, axis=1) # get the original dense labels of the test data"
      ],
      "metadata": {
        "id": "EcWAqwlDMq3y",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "64b64a3f-220f-4380-8aad-7641283509df"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "313/313 [==============================] - 1s 2ms/step\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 3.1. Exercise: Metrics\n",
        "please review the common classification metrics (accuracy, precision, recall, F1) for the complete model (not per class).\n",
        "\n",
        "Hints:\n",
        "* use macro averaging\n",
        "* you have to import the right functions from [sklearn.metrics](https://scikit-learn.org/stable/modules/model_evaluation.html)\n"
      ],
      "metadata": {
        "id": "RWJ-PH_iMs9K"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score"
      ],
      "metadata": {
        "id": "5sKm5zHSMZ_x"
      },
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Assuming 'predictions' are the predicted labels from your model\n",
        "print(\"Accuracy:\", accuracy_score(Y_test_dense, preds))\n",
        "print(\"Precision:\", precision_score(Y_test_dense, preds, average='macro'))\n",
        "print(\"Recall:\", recall_score(Y_test_dense, preds, average='macro'))\n",
        "print(\"F1:\", f1_score(Y_test_dense, preds, average='macro'))"
      ],
      "metadata": {
        "id": "I3_9wgDREUna",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1ddd5a3f-5f0e-4251-d2cc-dc1d40adb3f1"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Accuracy: 0.6836\n",
            "Precision: 0.6980976259440788\n",
            "Recall: 0.6836\n",
            "F1: 0.6860060690085901\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "## 3.2. Exercise: Confusion matrix\n",
        "Calculate the confusion matrix and display the results in a heatmap (with decimal values).\n",
        "\n",
        "Hints:\n",
        "* you have to do the imports this time too, e.g. from [sklearn.metrics](https://scikit-learn.org/stable/modules/model_evaluation.html) and the [heatmap function](https://seaborn.pydata.org/generated/seaborn.heatmap.html) of [seaborn](https://seaborn.pydata.org/)\n",
        "* for displaying the decimal values, you have to turn annot=True and define fmt='d' in the heatmap function of seaborn"
      ],
      "metadata": {
        "id": "ECHguBFtGL7f"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.metrics import confusion_matrix\n",
        "import seaborn as sns"
      ],
      "metadata": {
        "id": "SIi2VzMBO3yD"
      },
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cdqODx92Svw7",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 540
        },
        "outputId": "ce8df958-18f9-4cab-fcc3-0e4083b5d4b0"
      },
      "source": [
        "from sklearn.metrics import confusion_matrix\n",
        "import seaborn as sns\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "conf = confusion_matrix(Y_test_dense, preds)\n",
        "plt.figure(figsize=(7,6))\n",
        "sns.heatmap(conf, annot=True, fmt='d', cmap='Blues')\n"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<Axes: >"
            ]
          },
          "metadata": {},
          "execution_count": 19
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 700x600 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    }
  ]
}