Upload MNIST_Number.ipynb

MNIST_Number.ipynb

@@ -0,0 +1,567 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 14,
+      "metadata": {
+        "id": "9WolnzPUMmAb"
+      },
+      "outputs": [],
+      "source": [
+        "import tensorflow as tf\n",
+        "\n",
+        "from tensorflow import keras\n",
+        "from tensorflow.keras import datasets, layers, models\n",
+        "from keras.models import Sequential\n",
+        "from keras.layers import Conv2D, Lambda, MaxPooling2D # Convolution Layers\n",
+        "from keras.layers import Dense, Dropout, Flatten # Core Layers\n",
+        "\n",
+        "from keras.layers import BatchNormalization\n",
+        "from keras.preprocessing.image import ImageDataGenerator\n",
+        "\n",
+        "from keras.utils.np_utils import to_categorical\n",
+        "\n",
+        "from IPython.display import clear_output\n",
+        "\n",
+        "import numpy as np\n",
+        "import seaborn as sns\n",
+        "from PIL import Image\n",
+        "import os\n",
+        "import cv2 as cv\n",
+        "\n",
+        "%matplotlib inline\n",
+        "import matplotlib.pyplot as plt"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 15,
+      "metadata": {
+        "id": "ErHFgDeyNnFq"
+      },
+      "outputs": [],
+      "source": [
+        "(train_images, train_labels), (test_images, test_labels) = tf.keras.datasets.mnist.load_data()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 16,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 300
+        },
+        "id": "zNH-6C4dPqRA",
+        "outputId": "84bb1d3c-c08e-46bd-a781-c6b720652229"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "5\n"
+          ]
+        },
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<matplotlib.colorbar.Colorbar at 0x7fc2132d8dd0>"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 16
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 432x288 with 2 Axes>"
+            ]
+          },
+          "metadata": {
+            "needs_background": "light"
+          }
+        }
+      ],
+      "source": [
+        "prevnum = 0\n",
+        "print(train_labels[prevnum])\n",
+        "plt.imshow(train_images[prevnum])\n",
+        "plt.colorbar()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 17,
+      "metadata": {
+        "id": "iOw6UUoETPny"
+      },
+      "outputs": [],
+      "source": [
+        "train_images = train_images / 255.0\n",
+        "\n",
+        "test_images = test_images / 255.0"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 18,
+      "metadata": {
+        "id": "DuRqfPaaTRps"
+      },
+      "outputs": [],
+      "source": [
+        "model = Sequential()\n",
+        "\n",
+        "#model.add(Lambda(standardize,input_shape=(28,28,1)))    \n",
+        "model.add(Conv2D(filters=64, kernel_size = (3,3), activation=\"relu\", input_shape=(28,28,1)))\n",
+        "model.add(Conv2D(filters=64, kernel_size = (3,3), activation=\"relu\"))\n",
+        "\n",
+        "model.add(MaxPooling2D(pool_size=(2,2)))\n",
+        "model.add(BatchNormalization())\n",
+        "model.add(Conv2D(filters=128, kernel_size = (3,3), activation=\"relu\"))\n",
+        "model.add(Conv2D(filters=128, kernel_size = (3,3), activation=\"relu\"))\n",
+        "\n",
+        "model.add(MaxPooling2D(pool_size=(2,2)))\n",
+        "model.add(BatchNormalization())    \n",
+        "model.add(Conv2D(filters=256, kernel_size = (3,3), activation=\"relu\"))\n",
+        "    \n",
+        "model.add(MaxPooling2D(pool_size=(2,2)))\n",
+        "    \n",
+        "model.add(Flatten())\n",
+        "model.add(BatchNormalization())\n",
+        "model.add(Dense(512,activation=\"relu\"))\n",
+        "\n",
+        "model.add(Dense(10,activation=\"softmax\"))"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 19,
+      "metadata": {
+        "id": "3O9hJ9AwTUhC"
+      },
+      "outputs": [],
+      "source": [
+        "model.compile(\n",
+        "    optimizer=tf.keras.optimizers.Adam(learning_rate=1e-3, ),\n",
+        "    loss='sparse_categorical_crossentropy',\n",
+        "    metrics=['accuracy'])"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 20,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "5G8Y8suMTWHE",
+        "outputId": "091c55aa-5e1a-4eaa-e1da-a31302d3513d"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Epoch 1/2\n",
+            "938/938 [==============================] - 51s 53ms/step - loss: 0.0841 - accuracy: 0.9738 - val_loss: 0.0838 - val_accuracy: 0.9752\n",
+            "Epoch 2/2\n",
+            "938/938 [==============================] - 18s 19ms/step - loss: 0.0388 - accuracy: 0.9881 - val_loss: 0.0291 - val_accuracy: 0.9912\n"
+          ]
+        }
+      ],
+      "source": [
+        "history = model.fit(train_images, train_labels, epochs=3, batch_size=64, validation_data=(test_images, test_labels))"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from matplotlib import pyplot as plt\n",
+        "plt.plot(history.history['accuracy'])\n",
+        "plt.plot(history.history['val_accuracy'])\n",
+        "plt.title('model accuracy')\n",
+        "plt.ylabel('accuracy')\n",
+        "plt.xlabel('epoch')\n",
+        "plt.legend(['train', 'val'], loc='upper left')\n",
+        "plt.show()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 295
+        },
+        "id": "vk0YBQwAIQtb",
+        "outputId": "8ed954ff-ece4-40bb-86fa-75d433553aed"
+      },
+      "execution_count": 21,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 432x288 with 1 Axes>"
+            ]
+          },
+          "metadata": {
+            "needs_background": "light"
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "model.save('mnist-model.h5')"
+      ],
+      "metadata": {
+        "id": "skBnXBF6etJC"
+      },
+      "execution_count": 22,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 23,
+      "metadata": {
+        "id": "kHncTZNUTYNg",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "acdce7bd-d038-419e-e46e-ea912cd30f1f"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "313/313 [==============================] - 2s 7ms/step - loss: 0.0291 - accuracy: 0.9912\n",
+            "Test accuracy: 0.9911999702453613\n"
+          ]
+        }
+      ],
+      "source": [
+        "test_loss, test_acc = model.evaluate(test_images,  test_labels, verbose=1) \n",
+        "\n",
+        "print('Test accuracy:', test_acc)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 24,
+      "metadata": {
+        "id": "aetQfLO0T7W2",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "7ab4fb75-deb4-4320-c3da-c0d318ea80de"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Expected: 7\n",
+            "Predicted: 7\n"
+          ]
+        }
+      ],
+      "source": [
+        "predictions = model.predict(test_images, verbose=0)\n",
+        "\n",
+        "prednum = 0 # predict index\n",
+        "\n",
+        "print(f'Expected: {test_labels[prednum]}')\n",
+        "print(f'Predicted: {np.argmax(predictions[prednum])}')"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def plot_value_array(i, predictions_array, true_label):\n",
+        "  predictions_array, true_label = predictions_array[i], true_label[i]\n",
+        "  plt.grid(False)\n",
+        "  plt.xticks([0,1,2,3,4,5,6,7,8,9])\n",
+        "  plot = plt.bar(range(10), predictions_array, color=\"#777777\", align=\"center\")\n",
+        "  plt.ylim([0, 1]) \n",
+        "  predicted_label = np.argmax(predictions_array)\n",
+        "  plot[predicted_label].set_color('orange')"
+      ],
+      "metadata": {
+        "id": "XUjUnfCrjtJD"
+      },
+      "execution_count": 25,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 27,
+      "metadata": {
+        "id": "ULoUvS0IXtEc",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 253
+        },
+        "outputId": "cbee37a8-6797-4da4-9812-c58ed269be8d"
+      },
+      "outputs": [
+        {
+          "output_type": "error",
+          "ename": "error",
+          "evalue": "ignored",
+          "traceback": [
+            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+            "\u001b[0;31merror\u001b[0m                                     Traceback (most recent call last)",
+            "\u001b[0;32m<ipython-input-27-88d21d8fc9c4>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0mimage\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcv\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mimread\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mimg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcv\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mIMREAD_GRAYSCALE\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mimage\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcv\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mresize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mimage\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m28\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m28\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      7\u001b[0m \u001b[0mimage\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mimage\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0;36m255\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[0mimage\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mimage\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m28\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m28\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;31merror\u001b[0m: OpenCV(4.1.2) /io/opencv/modules/imgproc/src/resize.cpp:3720: error: (-215:Assertion failed) !ssize.empty() in function 'resize'\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Custom Image\n",
+        "\n",
+        "img = '/content/nine.png'\n",
+        "\n",
+        "image = cv.imread(img, cv.IMREAD_GRAYSCALE)\n",
+        "image = cv.resize(image, (28, 28))\n",
+        "image = image / 255\n",
+        "image = image.reshape((1, 28, 28))\n",
+        "\n",
+        "plt.imshow(image.reshape(28, 28))\n",
+        "plt.colorbar()\n",
+        "\n",
+        "predictions = model.predict(image, verbose=0)\n",
+        "\n",
+        "plt.xlabel(f\"Predicted: {np.argmax(predictions)}\")\n",
+        "\n",
+        "plt.show()\n",
+        "\n",
+        "plot_value_array(0, predictions, test_labels)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Gradio"
+      ],
+      "metadata": {
+        "id": "Q5asD9kQHeRC"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!pip install gradio"
+      ],
+      "metadata": {
+        "id": "E6iH4R3ZcT45",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "f283834e-7930-4025-dcb9-a0caba73a486"
+      },
+      "execution_count": 28,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Collecting gradio\n",
+            "  Downloading gradio-2.7.5.2-py3-none-any.whl (871 kB)\n",
+            "\u001b[K     |████████████████████████████████| 871 kB 4.3 MB/s \n",
+            "\u001b[?25hCollecting analytics-python\n",
+            "  Downloading analytics_python-1.4.0-py2.py3-none-any.whl (15 kB)\n",
+            "Collecting pydub\n",
+            "  Downloading pydub-0.25.1-py2.py3-none-any.whl (32 kB)\n",
+            "Collecting paramiko\n",
+            "  Downloading paramiko-2.9.2-py2.py3-none-any.whl (210 kB)\n",
+            "\u001b[K     |████████████████████████████████| 210 kB 48.5 MB/s \n",
+            "\u001b[?25hCollecting fastapi\n",
+            "  Downloading fastapi-0.73.0-py3-none-any.whl (52 kB)\n",
+            "\u001b[K     |████████████████████████████████| 52 kB 941 kB/s \n",
+            "\u001b[?25hRequirement already satisfied: matplotlib in /usr/local/lib/python3.7/dist-packages (from gradio) (3.2.2)\n",
+            "Collecting python-multipart\n",
+            "  Downloading python-multipart-0.0.5.tar.gz (32 kB)\n",
+            "Collecting aiohttp\n",
+            "  Downloading aiohttp-3.8.1-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl (1.1 MB)\n",
+            "\u001b[K     |████████████████████████████████| 1.1 MB 43.7 MB/s \n",
+            "\u001b[?25hCollecting markdown2\n",
+            "  Downloading markdown2-2.4.2-py2.py3-none-any.whl (34 kB)\n",
+            "Requirement already satisfied: requests in /usr/local/lib/python3.7/dist-packages (from gradio) (2.23.0)\n",
+            "Collecting pycryptodome\n",
+            "  Downloading pycryptodome-3.13.0-cp35-abi3-manylinux2010_x86_64.whl (2.0 MB)\n",
+            "\u001b[K     |████████████████████████████████| 2.0 MB 38.7 MB/s \n",
+            "\u001b[?25hRequirement already satisfied: pillow in /usr/local/lib/python3.7/dist-packages (from gradio) (7.1.2)\n",
+            "Requirement already satisfied: pandas in /usr/local/lib/python3.7/dist-packages (from gradio) (1.1.5)\n",
+            "Collecting ffmpy\n",
+            "  Downloading ffmpy-0.3.0.tar.gz (4.8 kB)\n",
+            "Collecting uvicorn\n",
+            "  Downloading uvicorn-0.17.0.post1-py3-none-any.whl (54 kB)\n",
+            "\u001b[K     |████████████████████████████████| 54 kB 3.2 MB/s \n",
+            "\u001b[?25hRequirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from gradio) (1.19.5)\n",
+            "Collecting aiosignal>=1.1.2\n",
+            "  Downloading aiosignal-1.2.0-py3-none-any.whl (8.2 kB)\n",
+            "Collecting multidict<7.0,>=4.5\n",
+            "  Downloading multidict-6.0.2-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (94 kB)\n",
+            "\u001b[K     |████████████████████████████████| 94 kB 3.6 MB/s \n",
+            "\u001b[?25hRequirement already satisfied: typing-extensions>=3.7.4 in /usr/local/lib/python3.7/dist-packages (from aiohttp->gradio) (3.10.0.2)\n",
+            "Collecting frozenlist>=1.1.1\n",
+            "  Downloading frozenlist-1.3.0-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl (144 kB)\n",
+            "\u001b[K     |████████████████████████████████| 144 kB 50.0 MB/s \n",
+            "\u001b[?25hRequirement already satisfied: attrs>=17.3.0 in /usr/local/lib/python3.7/dist-packages (from aiohttp->gradio) (21.4.0)\n",
+            "Collecting yarl<2.0,>=1.0\n",
+            "  Downloading yarl-1.7.2-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl (271 kB)\n",
+            "\u001b[K     |████████████████████████████████| 271 kB 53.2 MB/s \n",
+            "\u001b[?25hCollecting asynctest==0.13.0\n",
+            "  Downloading asynctest-0.13.0-py3-none-any.whl (26 kB)\n",
+            "Collecting async-timeout<5.0,>=4.0.0a3\n",
+            "  Downloading async_timeout-4.0.2-py3-none-any.whl (5.8 kB)\n",
+            "Requirement already satisfied: charset-normalizer<3.0,>=2.0 in /usr/local/lib/python3.7/dist-packages (from aiohttp->gradio) (2.0.10)\n",
+            "Requirement already satisfied: idna>=2.0 in /usr/local/lib/python3.7/dist-packages (from yarl<2.0,>=1.0->aiohttp->gradio) (2.10)\n",
+            "Requirement already satisfied: python-dateutil>2.1 in /usr/local/lib/python3.7/dist-packages (from analytics-python->gradio) (2.8.2)\n",
+            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.7/dist-packages (from analytics-python->gradio) (1.15.0)\n",
+            "Collecting monotonic>=1.5\n",
+            "  Downloading monotonic-1.6-py2.py3-none-any.whl (8.2 kB)\n",
+            "Collecting backoff==1.10.0\n",
+            "  Downloading backoff-1.10.0-py2.py3-none-any.whl (31 kB)\n",
+            "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests->gradio) (3.0.4)\n",
+            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests->gradio) (2021.10.8)\n",
+            "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from requests->gradio) (1.24.3)\n",
+            "Collecting pydantic!=1.7,!=1.7.1,!=1.7.2,!=1.7.3,!=1.8,!=1.8.1,<2.0.0,>=1.6.2\n",
+            "  Downloading pydantic-1.9.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (10.9 MB)\n",
+            "\u001b[K     |████████████████████████████████| 10.9 MB 33.7 MB/s \n",
+            "\u001b[?25hCollecting starlette==0.17.1\n",
+            "  Downloading starlette-0.17.1-py3-none-any.whl (58 kB)\n",
+            "\u001b[K     |████████████████████████████████| 58 kB 6.6 MB/s \n",
+            "\u001b[?25hCollecting anyio<4,>=3.0.0\n",
+            "  Downloading anyio-3.5.0-py3-none-any.whl (79 kB)\n",
+            "\u001b[K     |████████████████████████████████| 79 kB 7.9 MB/s \n",
+            "\u001b[?25hCollecting sniffio>=1.1\n",
+            "  Downloading sniffio-1.2.0-py3-none-any.whl (10 kB)\n",
+            "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->gradio) (1.3.2)\n",
+            "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->gradio) (3.0.7)\n",
+            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.7/dist-packages (from matplotlib->gradio) (0.11.0)\n",
+            "Requirement already satisfied: pytz>=2017.2 in /usr/local/lib/python3.7/dist-packages (from pandas->gradio) (2018.9)\n",
+            "Collecting bcrypt>=3.1.3\n",
+            "  Downloading bcrypt-3.2.0-cp36-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_24_x86_64.whl (61 kB)\n",
+            "\u001b[K     |████████████████████████████████| 61 kB 509 kB/s \n",
+            "\u001b[?25hCollecting pynacl>=1.0.1\n",
+            "  Downloading PyNaCl-1.5.0-cp36-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_24_x86_64.whl (856 kB)\n",
+            "\u001b[K     |████████████████████████████████| 856 kB 50.1 MB/s \n",
+            "\u001b[?25hCollecting cryptography>=2.5\n",
+            "  Downloading cryptography-36.0.1-cp36-abi3-manylinux_2_24_x86_64.whl (3.6 MB)\n",
+            "\u001b[K     |████████████████████████████████| 3.6 MB 33.9 MB/s \n",
+            "\u001b[?25hRequirement already satisfied: cffi>=1.1 in /usr/local/lib/python3.7/dist-packages (from bcrypt>=3.1.3->paramiko->gradio) (1.15.0)\n",
+            "Requirement already satisfied: pycparser in /usr/local/lib/python3.7/dist-packages (from cffi>=1.1->bcrypt>=3.1.3->paramiko->gradio) (2.21)\n",
+            "Requirement already satisfied: click>=7.0 in /usr/local/lib/python3.7/dist-packages (from uvicorn->gradio) (7.1.2)\n",
+            "Collecting h11>=0.8\n",
+            "  Downloading h11-0.13.0-py3-none-any.whl (58 kB)\n",
+            "\u001b[K     |████████████████████████████████| 58 kB 6.4 MB/s \n",
+            "\u001b[?25hCollecting asgiref>=3.4.0\n",
+            "  Downloading asgiref-3.5.0-py3-none-any.whl (22 kB)\n",
+            "Building wheels for collected packages: ffmpy, python-multipart\n",
+            "  Building wheel for ffmpy (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
+            "  Created wheel for ffmpy: filename=ffmpy-0.3.0-py3-none-any.whl size=4712 sha256=ca9eb79c3b709540745eb9192ba33eeb8b20e7fe0bd9895152ceaadb3f6f5fe5\n",
+            "  Stored in directory: /root/.cache/pip/wheels/13/e4/6c/e8059816e86796a597c6e6b0d4c880630f51a1fcfa0befd5e6\n",
+            "  Building wheel for python-multipart (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
+            "  Created wheel for python-multipart: filename=python_multipart-0.0.5-py3-none-any.whl size=31678 sha256=2dfaa979a3c41f2bc3dd446e266cdbb12251aaffc345ca1433c2b43d04894aca\n",
+            "  Stored in directory: /root/.cache/pip/wheels/2c/41/7c/bfd1c180534ffdcc0972f78c5758f89881602175d48a8bcd2c\n",
+            "Successfully built ffmpy python-multipart\n",
+            "Installing collected packages: sniffio, multidict, frozenlist, anyio, yarl, starlette, pynacl, pydantic, monotonic, h11, cryptography, bcrypt, backoff, asynctest, async-timeout, asgiref, aiosignal, uvicorn, python-multipart, pydub, pycryptodome, paramiko, markdown2, ffmpy, fastapi, analytics-python, aiohttp, gradio\n",
+            "Successfully installed aiohttp-3.8.1 aiosignal-1.2.0 analytics-python-1.4.0 anyio-3.5.0 asgiref-3.5.0 async-timeout-4.0.2 asynctest-0.13.0 backoff-1.10.0 bcrypt-3.2.0 cryptography-36.0.1 fastapi-0.73.0 ffmpy-0.3.0 frozenlist-1.3.0 gradio-2.7.5.2 h11-0.13.0 markdown2-2.4.2 monotonic-1.6 multidict-6.0.2 paramiko-2.9.2 pycryptodome-3.13.0 pydantic-1.9.0 pydub-0.25.1 pynacl-1.5.0 python-multipart-0.0.5 sniffio-1.2.0 starlette-0.17.1 uvicorn-0.17.0.post1 yarl-1.7.2\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import tensorflow as tf\n",
+        "import numpy as np\n",
+        "from urllib.request import urlretrieve\n",
+        "import gradio as gr\n",
+        "\n",
+        "model = tf.keras.models.load_model(\"mnist-model.h5\")\n",
+        "\n",
+        "def recognize_digit(image):\n",
+        "    image = cv.resize(image, (28, 28))\n",
+        "    image = image / 255\n",
+        "    image = image.reshape((1, 28, 28))\n",
+        "    prediction = model.predict(image).tolist()[0]\n",
+        "    return {str(i): prediction[i] for i in range(10)}\n",
+        "\n",
+        "gr.Interface(fn=recognize_digit, \n",
+        "             inputs=\"sketchpad\", \n",
+        "             outputs=gr.outputs.Label(num_top_classes=3),\n",
+        "             live=True,\n",
+        "             css=\".footer {display:none !important}\",\n",
+        "             # title=\"MNIST Sketchpad\",\n",
+        "             description=\"Draw a number 0 through 9 on the sketchpad, and see predictions in real time.\",\n",
+        "             thumbnail=\"https://raw.githubusercontent.com/gradio-app/real-time-mnist/master/thumbnail2.png\").launch();"
+      ],
+      "metadata": {
+        "id": "e3cHsKvRcVcQ",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 591
+        },
+        "outputId": "7f783403-f5f9-4816-e0de-401af8440edf"
+      },
+      "execution_count": 29,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Colab notebook detected. To show errors in colab notebook, set `debug=True` in `launch()`\n",
+            "Running on public URL: https://46805.gradio.app\n",
+            "\n",
+            "This share link expires in 72 hours. For free permanent hosting, check out Spaces (https://huggingface.co/spaces)\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/html": [
+              "\n",
+              "        <iframe\n",
+              "            width=\"900\"\n",
+              "            height=\"500\"\n",
+              "            src=\"https://46805.gradio.app\"\n",
+              "            frameborder=\"0\"\n",
+              "            allowfullscreen\n",
+              "        ></iframe>\n",
+              "        "
+            ],
+            "text/plain": [
+              "<IPython.lib.display.IFrame at 0x7fc288e99a10>"
+            ]
+          },
+          "metadata": {}
+        }
+      ]
+    }
+  ],
+  "metadata": {
+    "accelerator": "GPU",
+    "colab": {
+      "collapsed_sections": [],
+      "name": "MNIST Number.ipynb",
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}