{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "gpuClass": "standard",
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "50pmIeuTbnDN"
      },
      "outputs": [],
      "source": [
        "!mkdir -p ~/.kaggle\n",
        "!cp kaggle.json ~/.kaggle/"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# this model is going to classify that image has dog or cat\n",
        "!kaggle datasets download -d salader/dogs-vs-cats"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "C_gVQmSBgZE0",
        "outputId": "36a5a31e-42e8-4a4a-86d3-60838c175544"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Warning: Your Kaggle API key is readable by other users on this system! To fix this, you can run 'chmod 600 /root/.kaggle/kaggle.json'\n",
            "Downloading dogs-vs-cats.zip to /content\n",
            "100% 1.06G/1.06G [00:47<00:00, 24.6MB/s]\n",
            "100% 1.06G/1.06G [00:47<00:00, 23.9MB/s]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import zipfile\n",
        "zip_ref = zipfile.ZipFile('/content/dogs-vs-cats.zip','r')\n",
        "zip_ref.extractall('/content')\n",
        "zip_ref.close()"
      ],
      "metadata": {
        "id": "wMTy8YBUgpkm"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import tensorflow as tf\n",
        "from tensorflow import keras\n",
        "from keras import Sequential\n",
        "from keras.layers import Dense, Conv2D, MaxPooling2D, Flatten, BatchNormalization,Dropout"
      ],
      "metadata": {
        "id": "yT_qhrfTh1za"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Now what we have to do is that from train folder we have to give data to our model, for that we can write custom code for going to that particular folder and checking\n",
        "each any image and its labels which is very diffult to process such a huge data at once.\n",
        "\n",
        "keras uses concept to avoid this difulties know as \"Generators\" :- This generators devide all our data into batches of dataset which is very useful for dealing with\n",
        "large amount of data.\n",
        "\n",
        "\n",
        "\n",
        "'''\n",
        "train_ds = keras.utils.image_dataset_from_directory(\n",
        "    directory = '/content/train',\n",
        "    labels = 'inferred',\n",
        "    label_mode = 'int',\n",
        "    batch_size = 32,\n",
        "    image_size = (256,256)\n",
        ")\n",
        "\n",
        "validation_ds = keras.utils.image_dataset_from_directory(\n",
        "    directory = '/content/test',\n",
        "    labels = 'inferred',\n",
        "    label_mode = 'int',\n",
        "    batch_size = 32,\n",
        "    image_size = (256,256)\n",
        ")\n",
        "\n",
        "# The images stored here is in the form of numpy array\n",
        "# and each value of numpy is from 0 to 255 we have to make it from 0 to 1."
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PQonVZbUicUx",
        "outputId": "f69bdf02-40b2-48db-b862-2337cfb801b0"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found 20000 files belonging to 2 classes.\n",
            "Found 5000 files belonging to 2 classes.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# We have to Nirmalize the data for bringing it from 0- 255 to 0 - 1\n",
        "def process(image,label):\n",
        "  image = tf.cast(image/255, tf.float32)# we simply dividing over image value with 255\n",
        "  return image,label\n",
        "\n",
        "train_ds = train_ds.map(process)\n",
        "validation_ds = validation_ds.map(process)\n",
        "\n",
        "# map ()-> Every time it will extract one image and one label from the dataset and it apply process function on it and this fucntion will transform it and return it.\n",
        "\n"
      ],
      "metadata": {
        "id": "2ZbbFuqhmFi_"
      },
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Creating CNN model now\n",
        "# we will create 3 layers 1st will contain 32 filters 2nd will contain 64 filters and 3rd will contain 128 filters\n",
        "\n",
        "model = Sequential()\n",
        "# Our 1st Convolution layers\n",
        "model.add(Conv2D(32, kernel_size=(3,3), padding = 'valid', activation = 'relu', input_shape=(256,256,3)))\n",
        "\n",
        "model.add(BatchNormalization())\n",
        "# we will add pooling layer\n",
        "model.add(MaxPooling2D(pool_size = (2,2), strides = 2,padding = 'valid'))\n",
        "\n",
        "\n",
        "model.add(Conv2D(64, kernel_size=(3,3), padding = 'valid', activation = 'relu'))\n",
        "# we will add pooling layer\n",
        "model.add(BatchNormalization())\n",
        "model.add(MaxPooling2D(pool_size = (2,2), strides = 2,padding = 'valid'))\n",
        "\n",
        "\n",
        "\n",
        "model.add(Conv2D(128, kernel_size=(3,3), padding = 'valid', activation = 'relu'))\n",
        "# we will add pooling layer\n",
        "model.add(BatchNormalization())\n",
        "model.add(MaxPooling2D(pool_size = (2,2), strides = 2,padding = 'valid'))\n",
        "\n",
        "\n",
        "model.add(Flatten())\n",
        "\n",
        "\n",
        "# 128-> neurons we are using 3 fully connected models that's why we have to use 3 dense layers\n",
        "# this is output layer thats why we are going backward\n",
        "model.add(Dense(128,activation = 'relu'))\n",
        "model.add(Dropout(0.1))\n",
        "model.add(Dense(64, activation = 'relu'))\n",
        "model.add(Dense(1, activation = 'sigmoid'))"
      ],
      "metadata": {
        "id": "qjS-7NWDoDUS"
      },
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# summary of our model\n",
        "model.summary()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4AvrEOqFqSvr",
        "outputId": "2cef0f04-7df5-4a83-c9d1-3efeed238248"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " conv2d (Conv2D)             (None, 254, 254, 32)      896       \n",
            "                                                                 \n",
            " batch_normalization (BatchN  (None, 254, 254, 32)     128       \n",
            " ormalization)                                                   \n",
            "                                                                 \n",
            " max_pooling2d (MaxPooling2D  (None, 127, 127, 32)     0         \n",
            " )                                                               \n",
            "                                                                 \n",
            " conv2d_1 (Conv2D)           (None, 125, 125, 64)      18496     \n",
            "                                                                 \n",
            " batch_normalization_1 (Batc  (None, 125, 125, 64)     256       \n",
            " hNormalization)                                                 \n",
            "                                                                 \n",
            " max_pooling2d_1 (MaxPooling  (None, 62, 62, 64)       0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " conv2d_2 (Conv2D)           (None, 60, 60, 128)       73856     \n",
            "                                                                 \n",
            " batch_normalization_2 (Batc  (None, 60, 60, 128)      512       \n",
            " hNormalization)                                                 \n",
            "                                                                 \n",
            " max_pooling2d_2 (MaxPooling  (None, 30, 30, 128)      0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " flatten (Flatten)           (None, 115200)            0         \n",
            "                                                                 \n",
            " dense (Dense)               (None, 128)               14745728  \n",
            "                                                                 \n",
            " dropout (Dropout)           (None, 128)               0         \n",
            "                                                                 \n",
            " dense_1 (Dense)             (None, 64)                8256      \n",
            "                                                                 \n",
            " dense_2 (Dense)             (None, 1)                 65        \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 14,848,193\n",
            "Trainable params: 14,847,745\n",
            "Non-trainable params: 448\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "At last we have tensor (30,30,128) on whihc we applied Flattend model on it.\n"
      ],
      "metadata": {
        "id": "kh-wpagQqzmc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# compile our models\n",
        "# we will take binary crossentropy becasue this is binary class problem\n",
        "model.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'])\n"
      ],
      "metadata": {
        "id": "B6pzaknqqiTM"
      },
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "history = model.fit(train_ds, epochs = 1, validation_data = validation_ds)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3yJeIUUasWgc",
        "outputId": "b3f16cca-e889-4aab-d62a-8f397b7d6ea8"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "625/625 [==============================] - 83s 117ms/step - loss: 1.2445 - accuracy: 0.6025 - val_loss: 0.6663 - val_accuracy: 0.6576\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# we will check training accuracy and validation accuracy graph\n",
        "# To check how it is performing in this condition\n",
        "# import matplotlib.pyplot as plt\n",
        "# plt.plot(history.history['accuracy'], color = 'red', label = 'train')\n",
        "# plt.plot(history.history['val_accuracy'], color = 'blue',label = 'validation')\n",
        "# plt.legend()\n",
        "# plt.show()"
      ],
      "metadata": {
        "id": "BJ39UX6iso9s"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# we will check training accuracy and validation accuracy graph\n",
        "# To check how it is performing in this condition\n",
        "import matplotlib.pyplot as plt\n",
        "plt.plot(history.history['accuracy'], color = 'red', label = 'train')\n",
        "plt.plot(history.history['val_accuracy'], color = 'blue',label = 'validation')\n",
        "plt.legend()\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 268
        },
        "id": "mXnQLYCf1YMk",
        "outputId": "08e00be3-08d3-48cf-ab8f-7dc1d129a034"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "From this Graph it is clear that while training the accuracy is increasing but in validation accuracy is around 75% it is not increasing.\n",
        "Here is problem here is Overfitting"
      ],
      "metadata": {
        "id": "RKKXJN-RwdZU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# import matplotlib.pyplot as plt\n",
        "# plt.plot(history.history['loss'], color = 'red', label = 'train')\n",
        "# plt.plot(history.history['val_loss'], color = 'blue',label = 'validation')\n",
        "# plt.legend()\n",
        "# plt.show()"
      ],
      "metadata": {
        "id": "1WnbCldJwZ5V"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "## Ways to reduce overfitting \n",
        "\n",
        "# add more data\n",
        "# Data Augmentation\n",
        "# L1/L2 Regularizer\n",
        "# Dropout\n",
        "# Batch Norm\n",
        "# Reduce complexity\n",
        "\n",
        "\n",
        "# For applying bacth normalization we have to \"BatchNormalization, Dropout\" to improve the accuracy and to fit the model\n"
      ],
      "metadata": {
        "id": "eK6ig_irw48a"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "plt.plot(history.history['loss'], color = 'red', label = 'train')\n",
        "plt.plot(history.history['val_loss'], color = 'blue',label = 'validation')\n",
        "plt.legend()\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "id": "wVZBd2aC1bRi",
        "outputId": "e697508f-1b6c-45b6-b3c8-acf69d774a0d"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# for testing our image we have ti import open CV 1st\n",
        "import cv2\n"
      ],
      "metadata": {
        "id": "wnDtFy951iMJ"
      },
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "test_img = cv2.imread('/content/A-Cat.jpg')"
      ],
      "metadata": {
        "id": "vJGrYGqE3QNs"
      },
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "plt.imshow((test_img))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 287
        },
        "id": "uC5CzArg3Xf3",
        "outputId": "e61e3c87-3e28-4ca5-ace3-d39056ba89c2"
      },
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x7faf898319d0>"
            ]
          },
          "metadata": {},
          "execution_count": 34
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "test_img.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Dvbpr71p3a1m",
        "outputId": "f6355c84-925b-4475-deb5-be43d9f6f24f"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(2592, 3872, 3)"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# we have to resize our image to 256,256,3 \n",
        "test_img = cv2.resize(test_img, (256,256))\n"
      ],
      "metadata": {
        "id": "Baf8_YXa3o85"
      },
      "execution_count": 20,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "test_input = test_img.reshape((1,256,256,3))"
      ],
      "metadata": {
        "id": "bAqLWisK32jJ"
      },
      "execution_count": 22,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model.predict(test_input)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8B5okK7839Pa",
        "outputId": "87317705-cb96-4053-8496-54739d13dff1"
      },
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1/1 [==============================] - 0s 252ms/step\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0.]], dtype=float32)"
            ]
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We got result as 1 means 1 label is given to dog."
      ],
      "metadata": {
        "id": "T69rCqWS4O6K"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "test_img1 = cv2.imread('/content/images.jpeg')"
      ],
      "metadata": {
        "id": "tLimUEwm4Ihr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "plt.imshow(test_img1)"
      ],
      "metadata": {
        "id": "_RFpUb9r4ber"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "test_img1.shape"
      ],
      "metadata": {
        "id": "Sa7TrWoX4d44"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# we have to resize our image to 256,256,3 \n",
        "test_img1 = cv2.resize(test_img1, (256,256))"
      ],
      "metadata": {
        "id": "X8jtDKO_4jDL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "test_input1 = test_img1.reshape((1,256,256,3))"
      ],
      "metadata": {
        "id": "NtTv74S_4nHe"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model.predict(test_input1)"
      ],
      "metadata": {
        "id": "cpJwzW7X4yaQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import pickle\n",
        "file = open('Image_Classification_Using_CNN.pkl' , 'wb')"
      ],
      "metadata": {
        "id": "j4Mge2c6DR4W"
      },
      "execution_count": 24,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pickle.dump(model , file)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "p0DKU16vD5dU",
        "outputId": "d50460ae-f9ea-4d2a-8cbe-7ff523c06fe4"
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:absl:Found untraced functions such as _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op while saving (showing 3 of 3). These functions will not be directly callable after loading.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Here we have approx 0 values means this is considered as cat"
      ],
      "metadata": {
        "id": "vK58SExA5s3-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install gradio"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xBsjm-IpEaQy",
        "outputId": "0d603467-56b0-46db-d525-4e2157787072"
      },
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting gradio\n",
            "  Downloading gradio-3.16.2-py3-none-any.whl (14.2 MB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m14.2/14.2 MB\u001b[0m \u001b[31m83.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hRequirement already satisfied: pyyaml in /usr/local/lib/python3.8/dist-packages (from gradio) (6.0)\n",
            "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.8/dist-packages (from gradio) (4.4.0)\n",
            "Requirement already satisfied: jinja2 in /usr/local/lib/python3.8/dist-packages (from gradio) (2.11.3)\n",
            "Requirement already satisfied: pandas in /usr/local/lib/python3.8/dist-packages (from gradio) (1.3.5)\n",
            "Collecting python-multipart\n",
            "  Downloading python-multipart-0.0.5.tar.gz (32 kB)\n",
            "  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "Collecting markdown-it-py[linkify,plugins]\n",
            "  Downloading markdown_it_py-2.1.0-py3-none-any.whl (84 kB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m84.5/84.5 KB\u001b[0m \u001b[31m11.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hCollecting ffmpy\n",
            "  Downloading ffmpy-0.3.0.tar.gz (4.8 kB)\n",
            "  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "Requirement already satisfied: pillow in /usr/local/lib/python3.8/dist-packages (from gradio) (7.1.2)\n",
            "Requirement already satisfied: pydantic in /usr/local/lib/python3.8/dist-packages (from gradio) (1.10.4)\n",
            "Collecting uvicorn\n",
            "  Downloading uvicorn-0.20.0-py3-none-any.whl (56 kB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m56.9/56.9 KB\u001b[0m \u001b[31m7.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hCollecting aiofiles\n",
            "  Downloading aiofiles-22.1.0-py3-none-any.whl (14 kB)\n",
            "Collecting orjson\n",
            "  Downloading orjson-3.8.5-cp38-cp38-manylinux_2_28_x86_64.whl (140 kB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m140.6/140.6 KB\u001b[0m \u001b[31m17.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hRequirement already satisfied: altair>=4.2.0 in /usr/local/lib/python3.8/dist-packages (from gradio) (4.2.0)\n",
            "Collecting pycryptodome\n",
            "  Downloading pycryptodome-3.16.0-cp35-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl (2.3 MB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.3/2.3 MB\u001b[0m \u001b[31m89.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hRequirement already satisfied: matplotlib in /usr/local/lib/python3.8/dist-packages (from gradio) (3.2.2)\n",
            "Requirement already satisfied: markupsafe in /usr/local/lib/python3.8/dist-packages (from gradio) (2.0.1)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.8/dist-packages (from gradio) (1.21.6)\n",
            "Collecting pydub\n",
            "  Downloading pydub-0.25.1-py2.py3-none-any.whl (32 kB)\n",
            "Requirement already satisfied: aiohttp in /usr/local/lib/python3.8/dist-packages (from gradio) (3.8.3)\n",
            "Collecting websockets>=10.0\n",
            "  Downloading websockets-10.4-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl (106 kB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m107.0/107.0 KB\u001b[0m \u001b[31m14.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hCollecting httpx\n",
            "  Downloading httpx-0.23.3-py3-none-any.whl (71 kB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m71.5/71.5 KB\u001b[0m \u001b[31m9.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hRequirement already satisfied: fsspec in /usr/local/lib/python3.8/dist-packages (from gradio) (2022.11.0)\n",
            "Requirement already satisfied: requests in /usr/local/lib/python3.8/dist-packages (from gradio) (2.25.1)\n",
            "Collecting fastapi\n",
            "  Downloading fastapi-0.89.1-py3-none-any.whl (55 kB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m55.8/55.8 KB\u001b[0m \u001b[31m7.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hRequirement already satisfied: jsonschema>=3.0 in /usr/local/lib/python3.8/dist-packages (from altair>=4.2.0->gradio) (4.3.3)\n",
            "Requirement already satisfied: toolz in /usr/local/lib/python3.8/dist-packages (from altair>=4.2.0->gradio) (0.12.0)\n",
            "Requirement already satisfied: entrypoints in /usr/local/lib/python3.8/dist-packages (from altair>=4.2.0->gradio) (0.4)\n",
            "Requirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.8/dist-packages (from pandas->gradio) (2022.7)\n",
            "Requirement already satisfied: python-dateutil>=2.7.3 in /usr/local/lib/python3.8/dist-packages (from pandas->gradio) (2.8.2)\n",
            "Requirement already satisfied: yarl<2.0,>=1.0 in /usr/local/lib/python3.8/dist-packages (from aiohttp->gradio) (1.8.2)\n",
            "Requirement already satisfied: multidict<7.0,>=4.5 in /usr/local/lib/python3.8/dist-packages (from aiohttp->gradio) (6.0.4)\n",
            "Requirement already satisfied: frozenlist>=1.1.1 in /usr/local/lib/python3.8/dist-packages (from aiohttp->gradio) (1.3.3)\n",
            "Requirement already satisfied: charset-normalizer<3.0,>=2.0 in /usr/local/lib/python3.8/dist-packages (from aiohttp->gradio) (2.1.1)\n",
            "Requirement already satisfied: aiosignal>=1.1.2 in /usr/local/lib/python3.8/dist-packages (from aiohttp->gradio) (1.3.1)\n",
            "Requirement already satisfied: attrs>=17.3.0 in /usr/local/lib/python3.8/dist-packages (from aiohttp->gradio) (22.2.0)\n",
            "Requirement already satisfied: async-timeout<5.0,>=4.0.0a3 in /usr/local/lib/python3.8/dist-packages (from aiohttp->gradio) (4.0.2)\n",
            "Collecting starlette==0.22.0\n",
            "  Downloading starlette-0.22.0-py3-none-any.whl (64 kB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m64.3/64.3 KB\u001b[0m \u001b[31m8.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hCollecting anyio<5,>=3.4.0\n",
            "  Downloading anyio-3.6.2-py3-none-any.whl (80 kB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m80.6/80.6 KB\u001b[0m \u001b[31m10.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hCollecting sniffio\n",
            "  Downloading sniffio-1.3.0-py3-none-any.whl (10 kB)\n",
            "Requirement already satisfied: certifi in /usr/local/lib/python3.8/dist-packages (from httpx->gradio) (2022.12.7)\n",
            "Collecting rfc3986[idna2008]<2,>=1.3\n",
            "  Downloading rfc3986-1.5.0-py2.py3-none-any.whl (31 kB)\n",
            "Collecting httpcore<0.17.0,>=0.15.0\n",
            "  Downloading httpcore-0.16.3-py3-none-any.whl (69 kB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m69.6/69.6 KB\u001b[0m \u001b[31m10.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hCollecting mdurl~=0.1\n",
            "  Downloading mdurl-0.1.2-py3-none-any.whl (10.0 kB)\n",
            "Collecting linkify-it-py~=1.0\n",
            "  Downloading linkify_it_py-1.0.3-py3-none-any.whl (19 kB)\n",
            "Collecting mdit-py-plugins\n",
            "  Downloading mdit_py_plugins-0.3.3-py3-none-any.whl (50 kB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m50.5/50.5 KB\u001b[0m \u001b[31m6.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hRequirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.8/dist-packages (from matplotlib->gradio) (0.11.0)\n",
            "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib->gradio) (1.4.4)\n",
            "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib->gradio) (3.0.9)\n",
            "Requirement already satisfied: six>=1.4.0 in /usr/local/lib/python3.8/dist-packages (from python-multipart->gradio) (1.15.0)\n",
            "Requirement already satisfied: chardet<5,>=3.0.2 in /usr/local/lib/python3.8/dist-packages (from requests->gradio) (4.0.0)\n",
            "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /usr/local/lib/python3.8/dist-packages (from requests->gradio) (1.24.3)\n",
            "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.8/dist-packages (from requests->gradio) (2.10)\n",
            "Collecting h11>=0.8\n",
            "  Downloading h11-0.14.0-py3-none-any.whl (58 kB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m58.3/58.3 KB\u001b[0m \u001b[31m6.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hRequirement already satisfied: click>=7.0 in /usr/local/lib/python3.8/dist-packages (from uvicorn->gradio) (7.1.2)\n",
            "Requirement already satisfied: importlib-resources>=1.4.0 in /usr/local/lib/python3.8/dist-packages (from jsonschema>=3.0->altair>=4.2.0->gradio) (5.10.2)\n",
            "Requirement already satisfied: pyrsistent!=0.17.0,!=0.17.1,!=0.17.2,>=0.14.0 in /usr/local/lib/python3.8/dist-packages (from jsonschema>=3.0->altair>=4.2.0->gradio) (0.19.3)\n",
            "Collecting uc-micro-py\n",
            "  Downloading uc_micro_py-1.0.1-py3-none-any.whl (6.2 kB)\n",
            "Requirement already satisfied: zipp>=3.1.0 in /usr/local/lib/python3.8/dist-packages (from importlib-resources>=1.4.0->jsonschema>=3.0->altair>=4.2.0->gradio) (3.11.0)\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=4711 sha256=8647f9dadfba23a382140140e6ac1092e5544742fd7fda87b11176787eb277ad\n",
            "  Stored in directory: /root/.cache/pip/wheels/ff/5b/59/913b443e7369dc04b61f607a746b6f7d83fb65e2e19fcc958d\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=23651a675c88da99b9450bd66dc41a6067398471cb3add1795b846172bff3e63\n",
            "  Stored in directory: /root/.cache/pip/wheels/9e/fc/1c/cf980e6413d3ee8e70cd8f39e2366b0f487e3e221aeb452eb0\n",
            "Successfully built ffmpy python-multipart\n",
            "Installing collected packages: rfc3986, pydub, ffmpy, websockets, uc-micro-py, sniffio, python-multipart, pycryptodome, orjson, mdurl, h11, aiofiles, uvicorn, markdown-it-py, linkify-it-py, anyio, starlette, mdit-py-plugins, httpcore, httpx, fastapi, gradio\n",
            "Successfully installed aiofiles-22.1.0 anyio-3.6.2 fastapi-0.89.1 ffmpy-0.3.0 gradio-3.16.2 h11-0.14.0 httpcore-0.16.3 httpx-0.23.3 linkify-it-py-1.0.3 markdown-it-py-2.1.0 mdit-py-plugins-0.3.3 mdurl-0.1.2 orjson-3.8.5 pycryptodome-3.16.0 pydub-0.25.1 python-multipart-0.0.5 rfc3986-1.5.0 sniffio-1.3.0 starlette-0.22.0 uc-micro-py-1.0.1 uvicorn-0.20.0 websockets-10.4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import tensorflow as tf\n",
        "\n",
        "inception_net = tf.keras.applications.MobileNetV2()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4az_acCxGcjZ",
        "outputId": "c8314de9-3230-4d62-da26-a5ac9fc794cd"
      },
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading data from https://storage.googleapis.com/tensorflow/keras-applications/mobilenet_v2/mobilenet_v2_weights_tf_dim_ordering_tf_kernels_1.0_224.h5\n",
            "14536120/14536120 [==============================] - 2s 0us/step\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import requests\n",
        "\n",
        "# Download human-readable labels for ImageNet.\n",
        "response = requests.get(\"https://git.io/JJkYN\")\n",
        "labels = response.text.split(\"\\n\")\n",
        "\n",
        "def classify_image(inp):\n",
        "  inp = inp.reshape((1, 256, 256, 3))\n",
        "  inp = tf.keras.applications.mobilenet_v2.preprocess_input(inp)\n",
        "  prediction = model.predict(inp).flatten()\n",
        "  confidences = {labels[i]: float(prediction[i]) for i in range(1000)}\n",
        "  return confidences"
      ],
      "metadata": {
        "id": "7IG-I_g5Evhc"
      },
      "execution_count": 30,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import gradio as gr\n",
        "\n",
        "gr.Interface(fn=classify_image, \n",
        "             inputs=gr.Image(shape=(224, 224)),\n",
        "             outputs=gr.Label(num_top_classes=3),\n",
        "             examples=[\"/content/A-Cat.jpg\"]).launch()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 618
        },
        "id": "PdPqnD4c40hG",
        "outputId": "a5edd839-10c3-40a7-bfc0-283fc40cf90b"
      },
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Colab notebook detected. To show errors in colab notebook, set debug=True in launch()\n",
            "Note: opening Chrome Inspector may crash demo inside Colab notebooks.\n",
            "\n",
            "To create a public link, set `share=True` in `launch()`.\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "(async (port, path, width, height, cache, element) => {\n",
              "                        if (!google.colab.kernel.accessAllowed && !cache) {\n",
              "                            return;\n",
              "                        }\n",
              "                        element.appendChild(document.createTextNode(''));\n",
              "                        const url = await google.colab.kernel.proxyPort(port, {cache});\n",
              "\n",
              "                        const external_link = document.createElement('div');\n",
              "                        external_link.innerHTML = `\n",
              "                            <div style=\"font-family: monospace; margin-bottom: 0.5rem\">\n",
              "                                Running on <a href=${new URL(path, url).toString()} target=\"_blank\">\n",
              "                                    https://localhost:${port}${path}\n",
              "                                </a>\n",
              "                            </div>\n",
              "                        `;\n",
              "                        element.appendChild(external_link);\n",
              "\n",
              "                        const iframe = document.createElement('iframe');\n",
              "                        iframe.src = new URL(path, url).toString();\n",
              "                        iframe.height = height;\n",
              "                        iframe.allow = \"autoplay; camera; microphone; clipboard-read; clipboard-write;\"\n",
              "                        iframe.width = width;\n",
              "                        iframe.style.border = 0;\n",
              "                        element.appendChild(iframe);\n",
              "                    })(7860, \"/\", \"100%\", 500, false, window.element)"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": []
          },
          "metadata": {},
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "9-A-w0yREX4h"
      },
      "execution_count": 35,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "Tpvxtuc9tCYw"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}