road_sign.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyPzrJ9fvMYRaX5FcWbjJwOV",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU",
    "gpuClass": "standard"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/0xpix/Road-Sign-Tiny-VGG-architecture/blob/main/road_sign.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "! pip install opendatasets"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WHdmeuDEpFj_",
        "outputId": "97046dff-3aaf-4293-bba3-405d6825eaae"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting opendatasets\n",
            "  Downloading opendatasets-0.1.22-py3-none-any.whl (15 kB)\n",
            "Requirement already satisfied: kaggle in /usr/local/lib/python3.9/dist-packages (from opendatasets) (1.5.13)\n",
            "Requirement already satisfied: click in /usr/local/lib/python3.9/dist-packages (from opendatasets) (8.1.3)\n",
            "Requirement already satisfied: tqdm in /usr/local/lib/python3.9/dist-packages (from opendatasets) (4.65.0)\n",
            "Requirement already satisfied: urllib3 in /usr/local/lib/python3.9/dist-packages (from kaggle->opendatasets) (1.26.15)\n",
            "Requirement already satisfied: six>=1.10 in /usr/local/lib/python3.9/dist-packages (from kaggle->opendatasets) (1.16.0)\n",
            "Requirement already satisfied: requests in /usr/local/lib/python3.9/dist-packages (from kaggle->opendatasets) (2.27.1)\n",
            "Requirement already satisfied: python-slugify in /usr/local/lib/python3.9/dist-packages (from kaggle->opendatasets) (8.0.1)\n",
            "Requirement already satisfied: certifi in /usr/local/lib/python3.9/dist-packages (from kaggle->opendatasets) (2022.12.7)\n",
            "Requirement already satisfied: python-dateutil in /usr/local/lib/python3.9/dist-packages (from kaggle->opendatasets) (2.8.2)\n",
            "Requirement already satisfied: text-unidecode>=1.3 in /usr/local/lib/python3.9/dist-packages (from python-slugify->kaggle->opendatasets) (1.3)\n",
            "Requirement already satisfied: charset-normalizer~=2.0.0 in /usr/local/lib/python3.9/dist-packages (from requests->kaggle->opendatasets) (2.0.12)\n",
            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.9/dist-packages (from requests->kaggle->opendatasets) (3.4)\n",
            "Installing collected packages: opendatasets\n",
            "Successfully installed opendatasets-0.1.22\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import opendatasets as od\n",
        "\n",
        "# GTSRB - German Traffic Sign Recognition Dataset by Mykola\n",
        "od.download(\n",
        "\t\"https://www.kaggle.com/datasets/meowmeowmeowmeowmeow/gtsrb-german-traffic-sign\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Mw1hEOdgoRbs",
        "outputId": "0e036aca-2d02-44ea-e2cb-d871016d0825"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Please provide your Kaggle credentials to download this dataset. Learn more: http://bit.ly/kaggle-creds\n",
            "Your Kaggle username: nschlfat\n",
            "Your Kaggle Key: ··········\n",
            "Downloading gtsrb-german-traffic-sign.zip to ./gtsrb-german-traffic-sign\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 612M/612M [00:04<00:00, 136MB/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# import libraries\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import random\n",
        "\n",
        "# Tensorflow\n",
        "import tensorflow as tf\n",
        "from keras.utils import load_img, img_to_array\n",
        "from keras.optimizers import Adam\n",
        "from keras import layers, models"
      ],
      "metadata": {
        "id": "AXrNMlMgjFk8"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "train_data = pd.read_csv('gtsrb-german-traffic-sign/Train.csv')\n",
        "test_data = pd.read_csv('gtsrb-german-traffic-sign/Test.csv')"
      ],
      "metadata": {
        "id": "rAyEafxSpcxL"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "labels = {0:'Speed limit(20km/h)',\n",
        "          1:'Speed limit(30km/h)',\n",
        "          2:'Speed limit(50km/h)',\n",
        "          3:'Speed limit(60km/h)',\n",
        "          4:'Speed limit(70km/h)',\n",
        "          5:'Speed limit(80km/h)',\n",
        "          6:'End of speed limit(80km/h)',\n",
        "          7:'Speed limit(100km/h)',\n",
        "          8:'Speed limit(120km/h)',\n",
        "          9:'No passing',\n",
        "          10:'No passing for vehicles over 3.5 metric tons',\n",
        "          11:'Right-of-way at the next intersection',\n",
        "          12:'Priority road',\n",
        "          13:'Yield',\n",
        "          14:'Stop',\n",
        "          15:'No vehicles',\n",
        "          16:'Vehicles over 3.5 metric tons prohibted',\n",
        "          17:'No entry',\n",
        "          18:'General caution',\n",
        "          19:'Dangerous curve to the left',\n",
        "          20:'Dangerous curve to the right',\n",
        "          21:'Double curve',\n",
        "          22:'Bumpy road',\n",
        "          23:'Slippery road',\n",
        "          24:'Road narrows on the right',\n",
        "          25:'Road work',\n",
        "          26:'Traffic signals',\n",
        "          27:'Pedestrians',\n",
        "          28:'Children crossing',\n",
        "          29:'Bicycles crossing',\n",
        "          30:'Beware of ice/snow',\n",
        "          31:'Wild animals crossing',\n",
        "          32:'End of all speed and passing limits',\n",
        "          33:'Turn right ahead',\n",
        "          34:'Turn left ahead',\n",
        "          35:'Ahead only',\n",
        "          36:'Go straight or right',\n",
        "          37:'Go straight or left',\n",
        "          38:'Keep right',\n",
        "          39:'Keep left',\n",
        "          40:'Roundabout mandatory',\n",
        "          41:'End of no passing',\n",
        "          42:'End of no passing by vehicles over 3.5 metric tons'}"
      ],
      "metadata": {
        "id": "ZHYwd4J9FI7d"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# labels.values()"
      ],
      "metadata": {
        "id": "IXMphXxkINyq"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# # replace ClassId with the actual road sign name\n",
        "# train_data['ClassId'] = [labels[id] for id in train_data['ClassId']]\n",
        "# test_data['ClassId'] = [labels[id] for id in test_data['ClassId']]"
      ],
      "metadata": {
        "id": "tcfBwlbmIX7r"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# test_data"
      ],
      "metadata": {
        "id": "ex2z12x2Jzga"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# getting the Path and ClassId only\n",
        "train_data = train_data[['ClassId', 'Path']]\n",
        "test_data = test_data[['ClassId', 'Path']]"
      ],
      "metadata": {
        "id": "kYMQ1l0yJnEt"
      },
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "test_data.head()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 206
        },
        "id": "YpcjmA82KOIa",
        "outputId": "7cfb8462-9293-428e-8b06-894d1b466ab1"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "   ClassId            Path\n",
              "0       16  Test/00000.png\n",
              "1        1  Test/00001.png\n",
              "2       38  Test/00002.png\n",
              "3       33  Test/00003.png\n",
              "4       11  Test/00004.png"
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-92b99d3c-f916-439e-9df0-879dc12ce651\">\n",
              "    <div class=\"colab-df-container\">\n",
              "      <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>ClassId</th>\n",
              "      <th>Path</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>16</td>\n",
              "      <td>Test/00000.png</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>1</td>\n",
              "      <td>Test/00001.png</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>38</td>\n",
              "      <td>Test/00002.png</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>33</td>\n",
              "      <td>Test/00003.png</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>11</td>\n",
              "      <td>Test/00004.png</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-92b99d3c-f916-439e-9df0-879dc12ce651')\"\n",
              "              title=\"Convert this dataframe to an interactive table.\"\n",
              "              style=\"display:none;\">\n",
              "        \n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "       width=\"24px\">\n",
              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
              "  </svg>\n",
              "      </button>\n",
              "      \n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      flex-wrap:wrap;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "      <script>\n",
              "        const buttonEl =\n",
              "          document.querySelector('#df-92b99d3c-f916-439e-9df0-879dc12ce651 button.colab-df-convert');\n",
              "        buttonEl.style.display =\n",
              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "        async function convertToInteractive(key) {\n",
              "          const element = document.querySelector('#df-92b99d3c-f916-439e-9df0-879dc12ce651');\n",
              "          const dataTable =\n",
              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                     [key], {});\n",
              "          if (!dataTable) return;\n",
              "\n",
              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "            + ' to learn more about interactive tables.';\n",
              "          element.innerHTML = '';\n",
              "          dataTable['output_type'] = 'display_data';\n",
              "          await google.colab.output.renderOutput(dataTable, element);\n",
              "          const docLink = document.createElement('div');\n",
              "          docLink.innerHTML = docLinkHtml;\n",
              "          element.appendChild(docLink);\n",
              "        }\n",
              "      </script>\n",
              "    </div>\n",
              "  </div>\n",
              "  "
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "train_data['Path'] = 'gtsrb-german-traffic-sign/' + train_data['Path']\n",
        "test_data['Path'] = 'gtsrb-german-traffic-sign/' + test_data['Path']"
      ],
      "metadata": {
        "id": "8KqSUcRdjWM1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "train_data.Path[1]"
      ],
      "metadata": {
        "id": "Kfyz3MzyM38V",
        "outputId": "659a76d8-41d8-4995-e1e9-de03169d7837",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'gtsrb-german-traffic-sign/Train/20/00020_00000_00001.png'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# create a random number\n",
        "random_nbr = random.randint(1, len(train_data)) # or X.shape[0]\n",
        "\n",
        "# read the images randomly and plot'm\n",
        "img = plt.imread(train_data.Path[random_nbr])\n",
        "print(f'image shape : {img.shape}')\n",
        "plt.imshow(img)\n",
        "plt.title(labels[train_data.ClassId[random_nbr]])\n",
        "plt.axis('off')"
      ],
      "metadata": {
        "id": "27bju5EmmAsv",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 463
        },
        "outputId": "948e5649-72af-473c-d341-36774f3e7da0"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "image shape : (57, 58, 3)\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(-0.5, 57.5, 56.5, -0.5)"
            ]
          },
          "metadata": {},
          "execution_count": 13
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Split the data into training and validation sets\n",
        "train_data = train_data.sample(frac=0.8, random_state=0)\n",
        "valid_data = train_data.drop(train_data.index)\n",
        "\n",
        "# Preprocess the data\n",
        "IMG_SIZE = 32\n",
        "NUM_CLASSES = len(labels)\n",
        "\n",
        "def preprocess_data(df):\n",
        "    X = []\n",
        "    y = []\n",
        "    for index, row in df.iterrows():\n",
        "        img = load_img(row.Path, target_size=(IMG_SIZE, IMG_SIZE))\n",
        "        img_array = img_to_array(img) / 255.0\n",
        "        X.append(img_array)\n",
        "        y.append(tf.keras.utils.to_categorical(row.ClassId, num_classes=NUM_CLASSES))\n",
        "    return np.array(X), np.array(y)\n",
        "\n",
        "X_train, y_train = preprocess_data(train_data)\n",
        "X_valid, y_valid = preprocess_data(valid_data)\n",
        "X_test, y_test = preprocess_data(test_data)"
      ],
      "metadata": {
        "id": "Z1AUh1LIYYeF"
      },
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Define the model architecture\n",
        "model_2 = models.Sequential([\n",
        "    layers.Conv2D(32, (3, 3), activation='relu', input_shape=(IMG_SIZE, IMG_SIZE, 3)),\n",
        "    layers.Conv2D(64, (3, 3), activation='relu'),\n",
        "    layers.MaxPool2D((2, 2)),\n",
        "    layers.MaxPool2D((2, 2)),\n",
        "    layers.Conv2D(128, (3, 3), activation='relu'),\n",
        "    layers.Conv2D(64, (3, 3), activation='relu'),\n",
        "    layers.MaxPooling2D((2, 2)),\n",
        "    layers.Flatten(),\n",
        "    layers.Dense(128, activation='relu'),\n",
        "    layers.Dense(NUM_CLASSES, activation='softmax')\n",
        "])"
      ],
      "metadata": {
        "id": "262XeUNhKuGh"
      },
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model_2.summary()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "i6upjOLQcHJs",
        "outputId": "f072cc19-16ca-40f4-d043-20a88ceb1d87"
      },
      "execution_count": 16,
      "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",
            " conv2d_1 (Conv2D)           (None, 28, 28, 64)        18496     \n",
            "                                                                 \n",
            " max_pooling2d (MaxPooling2D  (None, 14, 14, 64)       0         \n",
            " )                                                               \n",
            "                                                                 \n",
            " max_pooling2d_1 (MaxPooling  (None, 7, 7, 64)         0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " conv2d_2 (Conv2D)           (None, 5, 5, 128)         73856     \n",
            "                                                                 \n",
            " conv2d_3 (Conv2D)           (None, 3, 3, 64)          73792     \n",
            "                                                                 \n",
            " max_pooling2d_2 (MaxPooling  (None, 1, 1, 64)         0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " flatten (Flatten)           (None, 64)                0         \n",
            "                                                                 \n",
            " dense (Dense)               (None, 128)               8320      \n",
            "                                                                 \n",
            " dense_1 (Dense)             (None, 43)                5547      \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 180,907\n",
            "Trainable params: 180,907\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model_2.compile(loss='categorical_crossentropy',\n",
        "              optimizer=Adam(),\n",
        "              metrics=['accuracy'])"
      ],
      "metadata": {
        "id": "Y8p115c0cKEd"
      },
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# fit the model\n",
        "history_2 = model_2.fit(X_train, \n",
        "                        y_train, \n",
        "                        epochs=5, \n",
        "                        validation_data=(X_valid, y_valid))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UfVj0S-0cW1b",
        "outputId": "2d1c12b4-7d8d-4a39-c87b-a57e89ed182d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/5\n",
            "981/981 [==============================] - 15s 5ms/step - loss: 1.2031 - accuracy: 0.6464\n",
            "Epoch 2/5\n",
            "981/981 [==============================] - 5s 5ms/step - loss: 0.1930 - accuracy: 0.9408\n",
            "Epoch 3/5\n",
            "981/981 [==============================] - 4s 5ms/step - loss: 0.0963 - accuracy: 0.9704\n",
            "Epoch 4/5\n",
            "594/981 [=================>............] - ETA: 2s - loss: 0.0653 - accuracy: 0.9801"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model_2.evaluate(X_test, y_test)"
      ],
      "metadata": {
        "id": "lz2mEwhjMPm7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pd.DataFrame(history_2.history).plot()"
      ],
      "metadata": {
        "id": "I7Y2Pa8Tue4q"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Get 12 random numbers\n",
        "rand_img = random.sample(range(len(X_test)), 12)\n",
        "\n",
        "# Get the predicted labels for the test data\n",
        "y_pred = model_2.predict(X_test)\n",
        "\n",
        "# Plot the images and the predicted labels\n",
        "fig, axs = plt.subplots(3, 4, figsize=(20, 12))\n",
        "axs = axs.ravel()\n",
        "for i in range(12):\n",
        "  # Plot the image\n",
        "  axs[i].imshow(X_test[rand_img[i]], cmap=plt.cm.binary)\n",
        "\n",
        "  # Get the predicted and actual label indices\n",
        "  pred_label = np.argmax(y_pred[rand_img[i]])\n",
        "  true_label = np.argmax(y_test[rand_img[i]])\n",
        "\n",
        "  # Change the color of the titles depending on if the prediction is right or wrong\n",
        "  if pred_label == true_label:\n",
        "     color = \"green\"\n",
        "  else:\n",
        "     color = \"red\"\n",
        "\n",
        "  # Set the label text\n",
        "  axs[i].set_title(\"Pred: {} {:2.0f}% \\n(True: {})\".format(labels[pred_label],\n",
        "                                                   100*tf.reduce_max(y_pred),\n",
        "                                                   labels[true_label]),\n",
        "             color=color) # set the color to green or red\n",
        "  axs[i].axis('off')\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "zLNwHiH3oX20"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}