model, interface, examples added

README.md

@@ -11,3 +11,8 @@ license: apache-2.0
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+<br/>
+
+HuggingFace Spaces App URL: https://huggingface.co/spaces/abrar-adnan/cap-recognizer
+
+Gradio App URL: https://8af6a681-9d64-4268.gradio.live

app.ipynb

@@ -0,0 +1,413 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "id": "JhrWoxK4jVbu"
+      },
+      "outputs": [],
+      "source": [
+        "#|detault_exp app"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "1kYzFQgGjjJ2"
+      },
+      "source": [
+        "#Cap Recognizer"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 2,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "ea5stcHYjcS-",
+        "outputId": "ddc979fa-51d8-49b3-b4fc-511cb5ca9495"
+      },
+      "outputs": [],
+      "source": [
+        "!pip install -Uqq fastai gradio nbdev"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 3,
+      "metadata": {
+        "id": "HkBHpDiwmuNw"
+      },
+      "outputs": [
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "c:\\Users\\Adnan\\anaconda3\\envs\\test\\lib\\site-packages\\tqdm\\auto.py:22: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+            "  from .autonotebook import tqdm as notebook_tqdm\n"
+          ]
+        }
+      ],
+      "source": [
+        "from fastai.vision.all import *"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 4,
+      "metadata": {
+        "id": "Dq5qTTfyjnSU"
+      },
+      "outputs": [],
+      "source": [
+        "#!export\n",
+        "from fastai.vision.all import load_learner\n",
+        "import gradio as gr"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 5,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "x6bzt3x3mImK",
+        "outputId": "36755ae9-e62d-4317-ded7-4f82d3e0270c"
+      },
+      "outputs": [
+        {
+          "ename": "ModuleNotFoundError",
+          "evalue": "No module named 'google'",
+          "output_type": "error",
+          "traceback": [
+            "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+            "\u001b[1;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)",
+            "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_10724\\1408506528.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;32mfrom\u001b[0m \u001b[0mgoogle\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcolab\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mdrive\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      2\u001b[0m \u001b[0mdrive\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmount\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'/content/drive'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
+            "\u001b[1;31mModuleNotFoundError\u001b[0m: No module named 'google'"
+          ]
+        }
+      ],
+      "source": [
+        "from google.colab import drive\n",
+        "drive.mount('/content/drive')"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 7,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "4gAkHrrhmJOz",
+        "outputId": "2fd647ea-c46a-474c-b7dd-35b268c33734"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "/content/drive/My Drive/Data_Science/cap_recognizer\n"
+          ]
+        }
+      ],
+      "source": [
+        "%cd /content/drive/My Drive/Data_Science/cap_recognizer"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 8,
+      "metadata": {
+        "id": "u0PUC8hvjxl9"
+      },
+      "outputs": [],
+      "source": [
+        "#!export\n",
+        "model = load_learner(f'models/cap-recognizer-v1.pkl')"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 9,
+      "metadata": {
+        "id": "AhLabGAAksjy"
+      },
+      "outputs": [],
+      "source": [
+        "#|export\n",
+        "cap_labels = (\n",
+        "     'balaclava cap', \n",
+        "     'baseball cap', \n",
+        "     'beanie cap', \n",
+        "     'boater hat', \n",
+        "     'bowler hat', \n",
+        "     'bucket hat', \n",
+        "     'cowboy hat', \n",
+        "     'fedora cap', \n",
+        "     'flat cap', \n",
+        "     'ivy cap', \n",
+        "     'kepi cap', \n",
+        "     'newsboy cap', \n",
+        "     'pork pie hat', \n",
+        "     'rasta cap', \n",
+        "     'sun hat', \n",
+        "     'taqiyah cap', \n",
+        "     'top hat', \n",
+        "     'trucker cap', \n",
+        "     'turban cap', \n",
+        "     'visor cap'\n",
+        ")\n",
+        "\n",
+        "def recognize_image(image):\n",
+        "    pred, idx, probs = model.predict(image)\n",
+        "    return dict(zip(cap_labels, map(float, probs)))"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 10,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 145
+        },
+        "id": "SQ9UDMQvljRm",
+        "outputId": "c5ccfd3b-d348-4641-d4bf-759618cbade2"
+      },
+      "outputs": [
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "PILImage mode=RGB size=98x128"
+            ]
+          },
+          "execution_count": 10,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "img = PILImage.create(f'test_images/unknown_01.jpg')\n",
+        "img.thumbnail((128,128))\n",
+        "img"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 11,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 374
+        },
+        "id": "ByribDDvl5WJ",
+        "outputId": "cedfa08a-b31e-4e08-abc2-f1110a4b74ed"
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/html": [
+              "\n",
+              "<style>\n",
+              "    /* Turns off some styling */\n",
+              "    progress {\n",
+              "        /* gets rid of default border in Firefox and Opera. */\n",
+              "        border: none;\n",
+              "        /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
+              "        background-size: auto;\n",
+              "    }\n",
+              "    progress:not([value]), progress:not([value])::-webkit-progress-bar {\n",
+              "        background: repeating-linear-gradient(45deg, #7e7e7e, #7e7e7e 10px, #5c5c5c 10px, #5c5c5c 20px);\n",
+              "    }\n",
+              "    .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
+              "        background: #F44336;\n",
+              "    }\n",
+              "</style>\n"
+            ],
+            "text/plain": [
+              "<IPython.core.display.HTML object>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "text/html": [],
+            "text/plain": [
+              "<IPython.core.display.HTML object>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "text/plain": [
+              "{'baseball cap': 2.031658914347645e-05,\n",
+              " 'beanie cap': 1.7680336895864457e-05,\n",
+              " 'fedora cap': 0.9962729215621948,\n",
+              " 'cowboy hat': 2.711957222345518e-06,\n",
+              " 'kepi cap': 9.686676094133873e-06,\n",
+              " 'flat cap': 4.283622274670051e-06,\n",
+              " 'trucker cap': 1.1603420801975517e-07,\n",
+              " 'newsboy cap': 2.5019651275215438e-06,\n",
+              " 'pork pie hat': 2.0958788809366524e-05,\n",
+              " 'bowler hat': 1.2604887160705402e-05,\n",
+              " 'top hat': 2.223709088866599e-06,\n",
+              " 'sun hat': 3.3140073355752975e-05,\n",
+              " 'boater hat': 7.091504130585236e-07,\n",
+              " 'ivy cap': 4.1056573536479846e-05,\n",
+              " 'bucket hat': 1.30015814647777e-06,\n",
+              " 'balaclava cap': 0.000930089910980314,\n",
+              " 'turban cap': 2.8767549338226672e-06,\n",
+              " 'taqiyah cap': 1.9568238712963648e-05,\n",
+              " 'rasta cap': 0.0015439128037542105,\n",
+              " 'visor cap': 0.0010612781625241041}"
+            ]
+          },
+          "execution_count": 11,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "recognize_image(img)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 13,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "3Nx7ghq3nCeo",
+        "outputId": "fcf759ff-41a9-4414-8e59-84c630efc1f8"
+      },
+      "outputs": [
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "/usr/local/lib/python3.8/dist-packages/gradio/inputs.py:257: UserWarning: Usage of gradio.inputs is deprecated, and will not be supported in the future, please import your component from gradio.components\n",
+            "  warnings.warn(\n",
+            "/usr/local/lib/python3.8/dist-packages/gradio/deprecation.py:40: UserWarning: `optional` parameter is deprecated, and it has no effect\n",
+            "  warnings.warn(value)\n",
+            "/usr/local/lib/python3.8/dist-packages/gradio/outputs.py:197: UserWarning: Usage of gradio.outputs is deprecated, and will not be supported in the future, please import your components from gradio.components\n",
+            "  warnings.warn(\n",
+            "/usr/local/lib/python3.8/dist-packages/gradio/deprecation.py:40: UserWarning: The 'type' parameter has been deprecated. Use the Number component instead.\n",
+            "  warnings.warn(value)\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Colab notebook detected. To show errors in colab notebook, set debug=True in launch()\n",
+            "Running on public URL: https://8af6a681-9d64-4268.gradio.live\n",
+            "\n",
+            "This share link expires in 72 hours. For free permanent hosting and GPU upgrades (NEW!), check out Spaces: https://huggingface.co/spaces\n"
+          ]
+        },
+        {
+          "data": {
+            "text/plain": []
+          },
+          "execution_count": 13,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "#!export\n",
+        "image = gr.inputs.Image(shape=(192,192))\n",
+        "label = gr.outputs.Label()\n",
+        "examples = [\n",
+        "    'test_images/unknown_00.jpg',\n",
+        "    'test_images/unknown_01.jpg',\n",
+        "    'test_images/unknown_02.jpg',\n",
+        "    'test_images/unknown_03.jpg'\n",
+        "]\n",
+        "\n",
+        "iface = gr.Interface(fn=recognize_image, inputs=image, outputs=label, examples=examples)\n",
+        "iface.launch(inline=False,share=True)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 312
+        },
+        "id": "q4R6rE74SHzN",
+        "outputId": "e02d02fb-bd86-4a46-8a8d-15f3b4b1a0b8"
+      },
+      "outputs": [
+        {
+          "ename": "ModuleNotFoundError",
+          "evalue": "ignored",
+          "output_type": "error",
+          "traceback": [
+            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+            "\u001b[0;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)",
+            "\u001b[0;32m<ipython-input-1-92ee83ce556b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mfrom\u001b[0m \u001b[0mnbdev\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexport\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mnotebook2script\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'nbdev'",
+            "",
+            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0;32m\nNOTE: If your import is failing due to a missing package, you can\nmanually install dependencies using either !pip or !apt.\n\nTo view examples of installing some common dependencies, click the\n\"Open Examples\" button below.\n\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n"
+          ]
+        }
+      ],
+      "source": [
+        "from nbdev.export import notebook2script"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "cSD7hGpYSLeJ"
+      },
+      "outputs": [],
+      "source": [
+        "notebook2script('app.ipynb')"
+      ]
+    }
+  ],
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "venv",
+      "language": "python",
+      "name": "python3"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 3
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython3"
+    },
+    "vscode": {
+      "interpreter": {
+        "hash": "8d892ed1b0ecf1c74748dc3295e5a5c5275095090a068651f08cc8ba4232eb8f"
+      }
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}

models/cap-recognizer-v1.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:67827ac616eb143c4f8493d07a2cb06cc847dfaa9d0df21bcbdeb303e12db7ba
+size 87579293