trafficwithmoreepoch (1).ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "cMBFrEbZUNqZ",
        "outputId": "40807c6d-821d-4bbd-fc13-5bc4332e098a"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Requirement already satisfied: kaggle in /usr/local/lib/python3.10/dist-packages (1.5.16)\n",
            "Requirement already satisfied: six>=1.10 in /usr/local/lib/python3.10/dist-packages (from kaggle) (1.16.0)\n",
            "Requirement already satisfied: certifi in /usr/local/lib/python3.10/dist-packages (from kaggle) (2023.11.17)\n",
            "Requirement already satisfied: python-dateutil in /usr/local/lib/python3.10/dist-packages (from kaggle) (2.8.2)\n",
            "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from kaggle) (2.31.0)\n",
            "Requirement already satisfied: tqdm in /usr/local/lib/python3.10/dist-packages (from kaggle) (4.66.1)\n",
            "Requirement already satisfied: python-slugify in /usr/local/lib/python3.10/dist-packages (from kaggle) (8.0.1)\n",
            "Requirement already satisfied: urllib3 in /usr/local/lib/python3.10/dist-packages (from kaggle) (2.0.7)\n",
            "Requirement already satisfied: bleach in /usr/local/lib/python3.10/dist-packages (from kaggle) (6.1.0)\n",
            "Requirement already satisfied: webencodings in /usr/local/lib/python3.10/dist-packages (from bleach->kaggle) (0.5.1)\n",
            "Requirement already satisfied: text-unidecode>=1.3 in /usr/local/lib/python3.10/dist-packages (from python-slugify->kaggle) (1.3)\n",
            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests->kaggle) (3.3.2)\n",
            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->kaggle) (3.6)\n"
          ]
        },
        {
          "data": {
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-feb5dad9-bdce-4d74-86d3-d8f6c28946af\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-feb5dad9-bdce-4d74-86d3-d8f6c28946af\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script>// Copyright 2017 Google LLC\n",
              "//\n",
              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
              "// you may not use this file except in compliance with the License.\n",
              "// You may obtain a copy of the License at\n",
              "//\n",
              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
              "//\n",
              "// Unless required by applicable law or agreed to in writing, software\n",
              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
              "// See the License for the specific language governing permissions and\n",
              "// limitations under the License.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Saving kaggle.json to kaggle.json\n",
            "Downloading ds3-datathon-traffic-signs.zip to /content\n",
            " 97% 299M/308M [00:02<00:00, 133MB/s] \n",
            "100% 308M/308M [00:02<00:00, 126MB/s]\n",
            "traffic_signs\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "WARNING:absl:`lr` is deprecated in Keras optimizer, please use `learning_rate` or use the legacy optimizer, e.g.,tf.keras.optimizers.legacy.Adam.\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Epoch 1/25\n",
            "980/980 [==============================] - 181s 182ms/step - loss: 1.8890 - accuracy: 0.4904 - val_loss: 0.4817 - val_accuracy: 0.8625 - lr: 0.0010\n",
            "Epoch 2/25\n",
            "980/980 [==============================] - 178s 181ms/step - loss: 0.5616 - accuracy: 0.8282 - val_loss: 0.0707 - val_accuracy: 0.9814 - lr: 0.0010\n",
            "Epoch 3/25\n",
            "980/980 [==============================] - 182s 185ms/step - loss: 0.3135 - accuracy: 0.9052 - val_loss: 0.0353 - val_accuracy: 0.9892 - lr: 0.0010\n",
            "Epoch 4/25\n",
            "980/980 [==============================] - 174s 177ms/step - loss: 0.2236 - accuracy: 0.9325 - val_loss: 0.0297 - val_accuracy: 0.9921 - lr: 0.0010\n",
            "Epoch 5/25\n",
            "980/980 [==============================] - 173s 176ms/step - loss: 0.1755 - accuracy: 0.9466 - val_loss: 0.0372 - val_accuracy: 0.9883 - lr: 0.0010\n",
            "Epoch 6/25\n",
            "980/980 [==============================] - 172s 175ms/step - loss: 0.1428 - accuracy: 0.9563 - val_loss: 0.0186 - val_accuracy: 0.9940 - lr: 0.0010\n",
            "Epoch 7/25\n",
            "980/980 [==============================] - 170s 174ms/step - loss: 0.1260 - accuracy: 0.9615 - val_loss: 0.0290 - val_accuracy: 0.9895 - lr: 0.0010\n",
            "Epoch 8/25\n",
            "980/980 [==============================] - 168s 172ms/step - loss: 0.1303 - accuracy: 0.9604 - val_loss: 0.0114 - val_accuracy: 0.9962 - lr: 0.0010\n",
            "Epoch 9/25\n",
            "980/980 [==============================] - 171s 175ms/step - loss: 0.1023 - accuracy: 0.9688 - val_loss: 0.1381 - val_accuracy: 0.9670 - lr: 0.0010\n",
            "Epoch 10/25\n",
            "980/980 [==============================] - 167s 171ms/step - loss: 0.0912 - accuracy: 0.9721 - val_loss: 0.0102 - val_accuracy: 0.9969 - lr: 0.0010\n",
            "Epoch 11/25\n",
            "980/980 [==============================] - 166s 169ms/step - loss: 0.1001 - accuracy: 0.9695 - val_loss: 0.0091 - val_accuracy: 0.9966 - lr: 0.0010\n",
            "Epoch 12/25\n",
            "980/980 [==============================] - 164s 167ms/step - loss: 0.0821 - accuracy: 0.9749 - val_loss: 0.0125 - val_accuracy: 0.9959 - lr: 0.0010\n",
            "Epoch 13/25\n",
            "980/980 [==============================] - 174s 178ms/step - loss: 0.0759 - accuracy: 0.9769 - val_loss: 0.0090 - val_accuracy: 0.9974 - lr: 0.0010\n",
            "Epoch 14/25\n",
            "980/980 [==============================] - 170s 173ms/step - loss: 0.0743 - accuracy: 0.9773 - val_loss: 0.0102 - val_accuracy: 0.9969 - lr: 0.0010\n",
            "Epoch 15/25\n",
            "980/980 [==============================] - 163s 167ms/step - loss: 0.0708 - accuracy: 0.9775 - val_loss: 0.0055 - val_accuracy: 0.9983 - lr: 0.0010\n",
            "Epoch 16/25\n",
            "980/980 [==============================] - 166s 169ms/step - loss: 0.0697 - accuracy: 0.9792 - val_loss: 0.0374 - val_accuracy: 0.9884 - lr: 0.0010\n",
            "Epoch 17/25\n",
            "980/980 [==============================] - 163s 166ms/step - loss: 0.0648 - accuracy: 0.9805 - val_loss: 0.0127 - val_accuracy: 0.9963 - lr: 0.0010\n",
            "Epoch 18/25\n",
            "980/980 [==============================] - 165s 169ms/step - loss: 0.0617 - accuracy: 0.9814 - val_loss: 0.0091 - val_accuracy: 0.9973 - lr: 0.0010\n",
            "Epoch 19/25\n",
            "980/980 [==============================] - 167s 171ms/step - loss: 0.0533 - accuracy: 0.9837 - val_loss: 0.0067 - val_accuracy: 0.9980 - lr: 0.0010\n",
            "Epoch 20/25\n",
            "980/980 [==============================] - 176s 179ms/step - loss: 0.0573 - accuracy: 0.9833 - val_loss: 0.0087 - val_accuracy: 0.9980 - lr: 0.0010\n",
            "Epoch 21/25\n",
            "980/980 [==============================] - 174s 178ms/step - loss: 0.0363 - accuracy: 0.9888 - val_loss: 0.0046 - val_accuracy: 0.9987 - lr: 2.0000e-04\n",
            "Epoch 22/25\n",
            "980/980 [==============================] - 172s 176ms/step - loss: 0.0277 - accuracy: 0.9913 - val_loss: 0.0037 - val_accuracy: 0.9990 - lr: 2.0000e-04\n",
            "Epoch 23/25\n",
            "980/980 [==============================] - 173s 177ms/step - loss: 0.0241 - accuracy: 0.9927 - val_loss: 0.0027 - val_accuracy: 0.9995 - lr: 2.0000e-04\n",
            "Epoch 24/25\n",
            "980/980 [==============================] - 175s 178ms/step - loss: 0.0259 - accuracy: 0.9922 - val_loss: 0.0024 - val_accuracy: 0.9995 - lr: 2.0000e-04\n",
            "Epoch 25/25\n",
            "980/980 [==============================] - 174s 177ms/step - loss: 0.0234 - accuracy: 0.9927 - val_loss: 0.0022 - val_accuracy: 0.9994 - lr: 2.0000e-04\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/keras/src/engine/training.py:3103: UserWarning: You are saving your model as an HDF5 file via `model.save()`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')`.\n",
            "  saving_api.save_model(\n"
          ]
        }
      ],
      "source": [
        "\n",
        "# Kaggle part \n",
        "!pip install kaggle\n",
        "from google.colab import files\n",
        "uploaded = files.upload()  # pls add the kaggle json file to get the dataset @ datathon team\n",
        "!mkdir -p ~/.kaggle\n",
        "!cp kaggle.json ~/.kaggle/\n",
        "!chmod 600 ~/.kaggle/kaggle.json\n",
        "!kaggle competitions download -c ds3-datathon-traffic-signs\n",
        "!unzip -q ds3-datathon-traffic-signs.zip -d /content/traffic_signs\n",
        "!ls /content/traffic_signs\n",
        "# the necessary libraries \n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "from PIL import Image\n",
        "from sklearn.model_selection import train_test_split\n",
        "from tensorflow.keras.utils import to_categorical\n",
        "from tensorflow.keras.models import Sequential\n",
        "from tensorflow.keras.layers import Conv2D, MaxPool2D, Dense, Flatten, Dropout, BatchNormalization\n",
        "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
        "from tensorflow.keras.optimizers import Adam\n",
        "from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau\n",
        "import os\n",
        "# citations : Towards datascience and analytics vidhya and data augmentation links attached in the slide deck for reference\n",
        "#  the function to load data  \n",
        "csv_path = '/content/traffic_signs/traffic_signs/traffic_train.csv'\n",
        "image_base_path = '/content/traffic_signs/traffic_signs/'\n",
        "def load_data(csv_path, base_path, img_size=(30, 30)):\n",
        "    data = []\n",
        "    labels = []\n",
        "    df = pd.read_csv(csv_path)\n",
        "    for idx, row in df.iterrows():\n",
        "        image_path = os.path.join(base_path, row['Path'])\n",
        "        try:\n",
        "            image = Image.open(image_path)\n",
        "            image = image.resize(img_size)\n",
        "            data.append(np.array(image))\n",
        "            labels.append(row['ClassId'])\n",
        "        except IOError as e:\n",
        "            print(f\"Error loading image: {image_path} - {e}\")\n",
        "    data = np.array(data)\n",
        "    labels = np.array(labels)\n",
        "    return data, labels\n",
        "\n",
        "\n",
        "\n",
        "# Load and preprocess data by calling teh above function\n",
        "data, labels = load_data(csv_path, image_base_path)\n",
        "\n",
        "# Splitting training and testing dataset\n",
        "X_train, X_test, y_train, y_test = train_test_split(data, labels, test_size=0.2, random_state=42)\n",
        "\n",
        "# Converting the labels into one hot encoding \n",
        "y_train = to_categorical(y_train, 43)\n",
        "y_test = to_categorical(y_test, 43)\n",
        "\n",
        "# Data Augmentation to recognise the different orientation of the image \n",
        "datagen = ImageDataGenerator(\n",
        "    rotation_range=10,\n",
        "    zoom_range=0.15,\n",
        "    width_shift_range=0.1,\n",
        "    height_shift_range=0.1,\n",
        "    shear_range=0.15,\n",
        "    horizontal_flip=False,\n",
        "    fill_mode=\"nearest\")\n",
        "\n",
        "# CNN model\n",
        "model = Sequential()\n",
        "\n",
        "# First Convolutional Block with the bigger kernel/matrix\n",
        "model.add(Conv2D(filters=32, kernel_size=(5,5), activation='relu', input_shape=X_train.shape[1:]))\n",
        "model.add(BatchNormalization())\n",
        "model.add(Conv2D(filters=32, kernel_size=(5,5), activation='relu'))\n",
        "model.add(BatchNormalization())\n",
        "model.add(MaxPool2D(pool_size=(2, 2)))\n",
        "model.add(Dropout(rate=0.25))\n",
        "\n",
        "# Second Convolutional Block with smaller kernel/matrix to observe the details \n",
        "model.add(Conv2D(filters=64, kernel_size=(3, 3), activation='relu'))\n",
        "model.add(BatchNormalization())\n",
        "model.add(Conv2D(filters=64, kernel_size=(3, 3), activation='relu'))\n",
        "model.add(BatchNormalization())\n",
        "model.add(MaxPool2D(pool_size=(2, 2)))\n",
        "model.add(Dropout(rate=0.25))\n",
        "\n",
        "# Flattening and Dense Layers\n",
        "model.add(Flatten())\n",
        "model.add(Dense(256, activation='relu'))\n",
        "model.add(BatchNormalization())\n",
        "model.add(Dropout(rate=0.5))\n",
        "model.add(Dense(43, activation='softmax')) # for multiclass classification 43 corresponds to number of classes \n",
        "\n",
        "# optimizing and compiling the model using standard values\n",
        "model.compile(loss='categorical_crossentropy', optimizer=Adam(lr=0.001), metrics=['accuracy'])\n",
        "\n",
        "# Callbacks to prevent overfitting issures , using standard values \n",
        "early_stopping = EarlyStopping(monitor='val_loss', patience=10, restore_best_weights=True)\n",
        "reduce_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.2, patience=5, min_lr=0.0001)\n",
        "\n",
        "# Training the model \n",
        "epochs = 25  \n",
        "batch_size = 32\n",
        "\n",
        "history = model.fit(datagen.flow(X_train, y_train, batch_size=batch_size),\n",
        "                    steps_per_epoch=len(X_train) // batch_size,\n",
        "                    epochs=epochs,\n",
        "                    validation_data=(X_test, y_test),\n",
        "                    callbacks=[early_stopping, reduce_lr])\n",
        "\n",
        "#Saving the model \n",
        "model.save(\"improved_traffic_classifier.h5\")\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 52
        },
        "id": "PozV5D9RnxVL",
        "outputId": "3fc2b1d8-e904-43d5-dd71-9bab7610a5e0"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "395/395 [==============================] - 16s 40ms/step\n",
            "Submission file saved to: /content/traffic_signs/traffic_submission.csv\n"
          ]
        },
        {
          "data": {
            "application/javascript": "\n    async function download(id, filename, size) {\n      if (!google.colab.kernel.accessAllowed) {\n        return;\n      }\n      const div = document.createElement('div');\n      const label = document.createElement('label');\n      label.textContent = `Downloading \"${filename}\": `;\n      div.appendChild(label);\n      const progress = document.createElement('progress');\n      progress.max = size;\n      div.appendChild(progress);\n      document.body.appendChild(div);\n\n      const buffers = [];\n      let downloaded = 0;\n\n      const channel = await google.colab.kernel.comms.open(id);\n      // Send a message to notify the kernel that we're ready.\n      channel.send({})\n\n      for await (const message of channel.messages) {\n        // Send a message to notify the kernel that we're ready.\n        channel.send({})\n        if (message.buffers) {\n          for (const buffer of message.buffers) {\n            buffers.push(buffer);\n            downloaded += buffer.byteLength;\n            progress.value = downloaded;\n          }\n        }\n      }\n      const blob = new Blob(buffers, {type: 'application/binary'});\n      const a = document.createElement('a');\n      a.href = window.URL.createObjectURL(blob);\n      a.download = filename;\n      div.appendChild(a);\n      a.click();\n      div.remove();\n    }\n  ",
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "application/javascript": "download(\"download_67f04370-9061-4e3d-98a7-2134b12494ff\", \"traffic_submission.csv\", 97770)",
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Function to load test data similar to the load data for training \n",
        "def load_test_data(csv_path, base_path, img_size=(30, 30)):\n",
        "    data = []\n",
        "    image_paths = []  \n",
        "    df = pd.read_csv(csv_path)\n",
        "    for idx, row in df.iterrows():\n",
        "        image_path = os.path.join(base_path, str(row['Path']))  \n",
        "        image = Image.open(image_path)\n",
        "        image = image.resize(img_size)\n",
        "        image = np.array(image)\n",
        "        data.append(image)\n",
        "        image_paths.append(image_path)\n",
        "    return np.array(data), image_paths\n",
        "\n",
        "\n",
        "test_csv_path = '/content/traffic_signs/traffic_signs/traffic_test.csv'\n",
        "test_image_base_path = '/content/traffic_signs/traffic_signs/'\n",
        "\n",
        "\n",
        "test_data, test_image_paths = load_test_data(test_csv_path, test_image_base_path)\n",
        "\n",
        "\n",
        "# Predict classes for the test data by using the model \n",
        "test_predictions = model.predict(test_data)\n",
        "predicted_classes = np.argmax(test_predictions, axis=1)\n",
        "\n",
        "# Create a submission DataFrame to convert to csv\n",
        "submission_df = pd.DataFrame({\n",
        "    'Id': range(0, len(predicted_classes)),  # Creates a column for Ids starting from 1 to the number of predictions\n",
        "    'ClassId': predicted_classes\n",
        "})\n",
        "\n",
        "# Save the submission \n",
        "submission_file_path = '/content/traffic_signs/traffic_submission.csv'\n",
        "submission_df.to_csv(submission_file_path, index=False)\n",
        "print(f'Submission file saved to: {submission_file_path}')\n",
        "\n",
        "# Optionally, download the submission file from colab :)\n",
        "from google.colab import files\n",
        "files.download(submission_file_path)\n"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}