Handritten_digit_recognition_using_NN_and_SVM.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "## Handwritten Digit Recognition Using Neural Networks and SVM"
      ],
      "metadata": {
        "id": "EkbVOJxMldRz"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Neural Netwroks\n",
        "\n",
        "tensorflow and Keras"
      ],
      "metadata": {
        "id": "K1LHV0i9lm-O"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import os\n",
        "import cv2\n",
        "import matplotlib.pyplot as plt\n",
        "import tensorflow as tf\n"
      ],
      "metadata": {
        "id": "9vyO4MHOaoCl"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "mnist = tf.keras.datasets.mnist"
      ],
      "metadata": {
        "id": "09TvI_StapIy"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "(X_train, y_train), (X_test, y_test) = mnist.load_data()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LhMafPz0apR6",
        "outputId": "f57224b0-e46e-4ccb-c3fb-4d94d3a49054"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz\n",
            "11490434/11490434 [==============================] - 0s 0us/step\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# normalizing data\n",
        "\n",
        "X_train = tf.keras.utils.normalize(X_train, axis=1)\n",
        "X_test = tf.keras.utils.normalize(X_test, axis=1)"
      ],
      "metadata": {
        "id": "X7RM26J7apaC"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model = tf.keras.models.Sequential()"
      ],
      "metadata": {
        "id": "Ke3ijCUXapes"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# flatten the layer (28x28)\n",
        "model.add(tf.keras.layers.Flatten(input_shape=(28, 28)))\n",
        "\n",
        "# dense layers\n",
        "model.add(tf.keras.layers.Dense(128, activation='relu'))\n",
        "model.add(tf.keras.layers.Dense(128, activation='relu'))\n",
        "model.add(tf.keras.layers.Dense(10, activation='softmax'))"
      ],
      "metadata": {
        "id": "nTUcWbZRcl__"
      },
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])"
      ],
      "metadata": {
        "id": "l581g1wEdFAi"
      },
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model.fit(X_train, y_train, epochs=3)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BA5BUiqWdxlh",
        "outputId": "61d8a62b-80de-4d82-953d-051c38394a32"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/3\n",
            "1875/1875 [==============================] - 7s 4ms/step - loss: 0.2051 - accuracy: 0.9423\n",
            "Epoch 2/3\n",
            "1875/1875 [==============================] - 8s 4ms/step - loss: 0.1148 - accuracy: 0.9672\n",
            "Epoch 3/3\n",
            "1875/1875 [==============================] - 7s 4ms/step - loss: 0.0862 - accuracy: 0.9756\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<keras.src.callbacks.History at 0x7d6e43f00160>"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model.save('handwritten.model')"
      ],
      "metadata": {
        "id": "JodNji0Gd494"
      },
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "loss, accuracy = model.evaluate(X_test, y_test)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KcjkND5QeZ-9",
        "outputId": "77c335b1-ff11-4642-abd3-c604a153f416"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "313/313 [==============================] - 1s 3ms/step - loss: 0.0935 - accuracy: 0.9719\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(loss)\n",
        "print(accuracy)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "z2jCTxDNel2b",
        "outputId": "e1dc3282-0059-45cc-b9af-e2cf9060f140"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.09351717680692673\n",
            "0.9718999862670898\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Uploading the test images with different digit to test the accuracy prediction of the model."
      ],
      "metadata": {
        "id": "oElkgdKjnOhr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import files\n",
        "import time\n",
        "\n",
        "# Upload images\n",
        "uploaded_files = files.upload()\n",
        "time.sleep(3)\n",
        "uploaded_files = files.upload()\n",
        "time.sleep(3)\n",
        "uploaded_files = files.upload()\n",
        "time.sleep(5)\n",
        "# Process uploaded images\n",
        "for image_number in range(1, 4):  # Assuming you have uploaded files named 1.png, 2.png, and 3.png\n",
        "    filename = f\"{image_number}.png\"\n",
        "\n",
        "    # Check if the uploaded file exists\n",
        "    if filename in uploaded_files:\n",
        "        try:\n",
        "            img = cv2.imread(filename)[:, :, 0]\n",
        "            img = np.invert(np.array([img]))\n",
        "            prediction = model.predict(img)\n",
        "            print(f\"This digit is probably {np.argmax(prediction)}\")\n",
        "            plt.imshow(img[0], cmap=plt.cm.binary)\n",
        "            plt.show()\n",
        "        except Exception as e:\n",
        "            print(f\"Error processing {filename}: {e}\")\n",
        "    else:\n",
        "        print(f\"{filename} not found among uploaded files.\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 668
        },
        "id": "IQ3p6JmmiRDf",
        "outputId": "e7668af4-24a7-45fd-885b-e1aae23216b3"
      },
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-f04a6e51-fc3f-41d0-891e-a0ef2b8a723c\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-f04a6e51-fc3f-41d0-891e-a0ef2b8a723c\">\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> "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving 1.png to 1.png\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-08cabe32-29a4-4776-8288-c5a46a758040\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-08cabe32-29a4-4776-8288-c5a46a758040\">\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> "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving 2.png to 2.png\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-357d233a-9a1f-476b-9f4e-b458231e9c5f\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-357d233a-9a1f-476b-9f4e-b458231e9c5f\">\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> "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving 3.png to 3.png\n",
            "1.png not found among uploaded files.\n",
            "2.png not found among uploaded files.\n",
            "1/1 [==============================] - 0s 18ms/step\n",
            "This digit is probably 6\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Neural Network accurately predict the digit."
      ],
      "metadata": {
        "id": "1FVqSV-gnCnr"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Using SVM\n",
        "\n",
        "openml"
      ],
      "metadata": {
        "id": "qBJ77FKFlWfY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from sklearn.datasets import fetch_openml\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn import svm\n",
        "from sklearn import metrics\n"
      ],
      "metadata": {
        "id": "_HqGi1pHB2sv"
      },
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Load the MNIST dataset\n",
        "mnist = fetch_openml(\"mnist_784\")\n",
        "X = mnist.data.astype(\"float32\")\n",
        "y = mnist.target.astype(\"int\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "J27EgDXAE07t",
        "outputId": "21c406fe-ef88-4406-dd78-f88ad4ec8ef6"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/sklearn/datasets/_openml.py:968: FutureWarning: The default value of `parser` will change from `'liac-arff'` to `'auto'` in 1.4. You can set `parser='auto'` to silence this warning. Therefore, an `ImportError` will be raised from 1.4 if the dataset is dense and pandas is not installed. Note that the pandas parser may return different data types. See the Notes Section in fetch_openml's API doc for details.\n",
            "  warn(\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Split the dataset into training and testing sets\n",
        "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)"
      ],
      "metadata": {
        "id": "TLRnKjciE3qz"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a Support Vector Machine (SVM) classifier\n",
        "clf = svm.SVC(gamma=0.001)"
      ],
      "metadata": {
        "id": "qhnn7eEdE6S1"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Train the classifier on the training data\n",
        "clf.fit(X_train, y_train)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 74
        },
        "id": "EZdX1eoyE8tv",
        "outputId": "2c28df56-3bdc-4704-84c8-06bc744262b2"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "SVC(gamma=0.001)"
            ],
            "text/html": [
              "<style>#sk-container-id-1 {color: black;background-color: white;}#sk-container-id-1 pre{padding: 0;}#sk-container-id-1 div.sk-toggleable {background-color: white;}#sk-container-id-1 label.sk-toggleable__label {cursor: pointer;display: block;width: 100%;margin-bottom: 0;padding: 0.3em;box-sizing: border-box;text-align: center;}#sk-container-id-1 label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-1 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-1 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-1 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-1 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-1 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-1 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-container-id-1 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 input.sk-hidden--visually {border: 0;clip: rect(1px 1px 1px 1px);clip: rect(1px, 1px, 1px, 1px);height: 1px;margin: -1px;overflow: hidden;padding: 0;position: absolute;width: 1px;}#sk-container-id-1 div.sk-estimator {font-family: monospace;background-color: #f0f8ff;border: 1px dotted black;border-radius: 0.25em;box-sizing: border-box;margin-bottom: 0.5em;}#sk-container-id-1 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-1 div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-1 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-serial::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: 0;}#sk-container-id-1 div.sk-serial {display: flex;flex-direction: column;align-items: center;background-color: white;padding-right: 0.2em;padding-left: 0.2em;position: relative;}#sk-container-id-1 div.sk-item {position: relative;z-index: 1;}#sk-container-id-1 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-1 div.sk-item::before, #sk-container-id-1 div.sk-parallel-item::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: -1;}#sk-container-id-1 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-1 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-1 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-1 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-1 div.sk-dashed-wrapped {border: 1px dashed gray;margin: 0 0.4em 0.5em 0.4em;box-sizing: border-box;padding-bottom: 0.4em;background-color: white;}#sk-container-id-1 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-1 div.sk-label-container {text-align: center;}#sk-container-id-1 div.sk-container {/* jupyter's `normalize.less` sets `[hidden] { display: none; }` but bootstrap.min.css set `[hidden] { display: none !important; }` so we also need the `!important` here to be able to override the default hidden behavior on the sphinx rendered scikit-learn.org. See: https://github.com/scikit-learn/scikit-learn/issues/21755 */display: inline-block !important;position: relative;}#sk-container-id-1 div.sk-text-repr-fallback {display: none;}</style><div id=\"sk-container-id-1\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>SVC(gamma=0.001)</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-1\" type=\"checkbox\" checked><label for=\"sk-estimator-id-1\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">SVC</label><div class=\"sk-toggleable__content\"><pre>SVC(gamma=0.001)</pre></div></div></div></div></div>"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "# Predict the labels for the test set\n",
        "y_pred = clf.predict(X_test)\n"
      ],
      "metadata": {
        "id": "7q1I776QE_AI"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Calculate and print the classification report\n",
        "print(\"Classification Report:\\n\", metrics.classification_report(y_test, y_pred))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DFAE--_zFBjY",
        "outputId": "9bf438c8-aa2c-4d21-d111-24f93b4ee82f"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Classification Report:\n",
            "               precision    recall  f1-score   support\n",
            "\n",
            "           0       0.00      0.00      0.00      1343\n",
            "           1       0.11      1.00      0.21      1600\n",
            "           2       0.00      0.00      0.00      1380\n",
            "           3       0.00      0.00      0.00      1433\n",
            "           4       0.00      0.00      0.00      1295\n",
            "           5       0.00      0.00      0.00      1273\n",
            "           6       0.00      0.00      0.00      1396\n",
            "           7       0.00      0.00      0.00      1503\n",
            "           8       0.00      0.00      0.00      1357\n",
            "           9       0.00      0.00      0.00      1420\n",
            "\n",
            "    accuracy                           0.11     14000\n",
            "   macro avg       0.01      0.10      0.02     14000\n",
            "weighted avg       0.01      0.11      0.02     14000\n",
            "\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
            "  _warn_prf(average, modifier, msg_start, len(result))\n",
            "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
            "  _warn_prf(average, modifier, msg_start, len(result))\n",
            "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
            "  _warn_prf(average, modifier, msg_start, len(result))\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The warning messages at the end of the report indicate that precision and F1-score are ill-defined for some classes because there are no predicted samples for those classes. This suggests that model might not be well-trained or that there's an issue with the class distribution in dataset.\n",
        "\n",
        "To improve the performance of model, may need to:\n",
        "\n",
        "  1. Investigate the class distribution in dataset. If some classes have very few samples, it can be challenging for the model to learn them effectively.\n",
        "  2. Experiment with different machine learning algorithms or model hyperparameters. SVM with default hyperparameters may not be the best choice for this problem.\n",
        "  3. Consider preprocessing steps such as data normalization, feature scaling, or dimensionality reduction techniques to improve model performance.\n",
        "\n",
        "    \n",
        "\n",
        "    "
      ],
      "metadata": {
        "id": "F3stdZUNmdvq"
      }
    }
  ]
}