model,interface,examples added

.gitignore

@@ -0,0 +1,2 @@
+**/__pycache__/
+venv/

README.md

@@ -10,4 +10,8 @@ pinned: false
 license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference <br/>
+
+HuggingFace spaces app URL : https://huggingface.co/spaces/mhdhrubo/indian_classical_musical_instrument_recognizer
+
+Gradio app URL : https://d713594b371184c30d.gradio.live/

app.ipynb

@@ -0,0 +1,329 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "id": "UtWMVEPUgurg"
+      },
+      "outputs": [],
+      "source": [
+        "#|default_exp app"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "wU2LMUSGhUbE"
+      },
+      "source": [
+        "#Musical Instrument Recognizer"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "3txLmR_EhYZA",
+        "outputId": "2f7a0b63-d437-42db-cc3a-bac114b2b184"
+      },
+      "outputs": [
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "ERROR: Some build dependencies for cymem==2.0.2 from https://files.pythonhosted.org/packages/8b/dc/0976e04cc46f86e0dd3ee3797ec68057eaafebf31daca9a076dc138b9920/cymem-2.0.2.tar.gz (from fastai) conflict with the backend dependencies: wheel==0.42.0 is incompatible with wheel>=0.32.0,<0.33.0.\n"
+          ]
+        }
+      ],
+      "source": [
+        "!pip install -Uqq fastai fastbook nbdev gradio"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "id": "15NDmjd8hmMm"
+      },
+      "outputs": [
+        {
+          "ename": "ModuleNotFoundError",
+          "evalue": "No module named 'fastai'",
+          "output_type": "error",
+          "traceback": [
+            "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+            "\u001b[1;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)",
+            "\u001b[1;32md:\\Data Science\\MasterCourse\\Capstone Project 2 - image recognizer\\Project Files\\indian_classical_musical_instrument_recognizer\\app.ipynb Cell 4\u001b[0m line \u001b[0;36m2\n\u001b[0;32m      <a href='vscode-notebook-cell:/d%3A/Data%20Science/MasterCourse/Capstone%20Project%202%20-%20image%20recognizer/Project%20Files/indian_classical_musical_instrument_recognizer/app.ipynb#W5sZmlsZQ%3D%3D?line=0'>1</a>\u001b[0m \u001b[39m#!export\u001b[39;00m\n\u001b[1;32m----> <a href='vscode-notebook-cell:/d%3A/Data%20Science/MasterCourse/Capstone%20Project%202%20-%20image%20recognizer/Project%20Files/indian_classical_musical_instrument_recognizer/app.ipynb#W5sZmlsZQ%3D%3D?line=1'>2</a>\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mfastai\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mvision\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mall\u001b[39;00m \u001b[39mimport\u001b[39;00m load_learner\n\u001b[0;32m      <a href='vscode-notebook-cell:/d%3A/Data%20Science/MasterCourse/Capstone%20Project%202%20-%20image%20recognizer/Project%20Files/indian_classical_musical_instrument_recognizer/app.ipynb#W5sZmlsZQ%3D%3D?line=2'>3</a>\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mgradio\u001b[39;00m \u001b[39mas\u001b[39;00m \u001b[39mgr\u001b[39;00m\n",
+            "\u001b[1;31mModuleNotFoundError\u001b[0m: No module named 'fastai'"
+          ]
+        }
+      ],
+      "source": [
+        "#!export\n",
+        "from fastai.vision.all import load_learner\n",
+        "import gradio as gr"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 16,
+      "metadata": {
+        "id": "CXrdoKsLiCgz"
+      },
+      "outputs": [],
+      "source": [
+        "#!export\n",
+        "model = load_learner(f\"models/musical-instrument-recognizer-v6.pkl\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 17,
+      "metadata": {
+        "id": "ikyofbmki9rk"
+      },
+      "outputs": [],
+      "source": [
+        "#|export\n",
+        "musical_instruments = (\n",
+        "    'Bansuri',\n",
+        "    'Harmonium',\n",
+        "    'Pakhawaz',\n",
+        "    'Santoor',\n",
+        "    'Sarangi',\n",
+        "    'Sarod',\n",
+        "    'Shehnai',\n",
+        "    'Sitar',\n",
+        "    'Tabla',\n",
+        "    'Tanpura'\n",
+        ")\n",
+        "\n",
+        "def recognize_image(image):\n",
+        "  pred, idx, probs = model.predict(image)\n",
+        "  return dict(zip(musical_instruments, map(float, probs)))"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 18,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 209
+        },
+        "id": "8QOU1viCkYPy",
+        "outputId": "df789043-f5df-4c1a-e581-5ce62439f948"
+      },
+      "outputs": [
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<PIL.JpegImagePlugin.JpegImageFile image mode=RGB size=192x192>"
+            ]
+          },
+          "execution_count": 18,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "from PIL import Image\n",
+        "img = Image.open(f'test_data/bansuri.jfif')\n",
+        "img.thumbnail((192,192))\n",
+        "img"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 19,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 191
+        },
+        "id": "GjFbAe0WlPX5",
+        "outputId": "d94b325b-4c3e-4b9d-800f-450fc8b30413"
+      },
+      "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": [
+              "{'Bansuri': 0.9995973706245422,\n",
+              " 'Harmonium': 3.5202569961256813e-06,\n",
+              " 'Pakhawaz': 2.915377308454481e-06,\n",
+              " 'Santoor': 2.1727865373577515e-07,\n",
+              " 'Sarangi': 4.1493856883789704e-07,\n",
+              " 'Sarod': 1.0827788088363377e-07,\n",
+              " 'Shehnai': 0.0003836842952296138,\n",
+              " 'Sitar': 9.002708793559577e-06,\n",
+              " 'Tabla': 2.717604274948826e-06,\n",
+              " 'Tanpura': 1.3091357686789706e-07}"
+            ]
+          },
+          "execution_count": 19,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "recognize_image(img)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 20,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "_3eo0O8tmwi5",
+        "outputId": "eeb35528-c779-46d6-cc8a-3c39efca8dbb"
+      },
+      "outputs": [
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "/usr/local/lib/python3.10/dist-packages/gradio/inputs.py:256: 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.10/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.10/dist-packages/gradio/outputs.py:196: 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.10/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": [
+            "IMPORTANT: You are using gradio version 3.13.0, however version 3.14.0 is available, please upgrade.\n",
+            "--------\n",
+            "Colab notebook detected. To show errors in colab notebook, set debug=True in launch()\n",
+            "\n",
+            "Setting up a public link... we have recently upgraded the way public links are generated. If you encounter any problems, please report the issue and downgrade to gradio version 3.13.0\n",
+            ".\n",
+            "Running on public URL: https://9fc74c01-6bc9-4897.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": 20,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "#!export\n",
+        "image = gr.inputs.Image(shape=(192,192))\n",
+        "label = gr.outputs.Label()\n",
+        "examples = [\n",
+        "    'test_data/bansuri.jfif',\n",
+        "    'test_data/harmonium.jfif',\n",
+        "    'test_data/pakhawaj.jfif',\n",
+        "    'test_data/santoor.jfif',\n",
+        "    'test_data/sarengi.jfif',\n",
+        "    'test_data/sarod.jfif',\n",
+        "    'test_data/shehnai.jfif',\n",
+        "    'test_data/sitar.jfif',\n",
+        "    'test_data/tabla.jfif',\n",
+        "    'test_data/tanpura.jfif'\n",
+        "]\n",
+        "\n",
+        "iface = gr.Interface(fn=recognize_image, inputs = image, outputs= label, examples = examples)\n",
+        "iface.launch(inline =False, share = True)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "lMYKAOtLuLLA"
+      },
+      "source": [
+        "# Notebook to Python Script Export"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 22,
+      "metadata": {
+        "id": "mkTtKu_GuPHT"
+      },
+      "outputs": [],
+      "source": [
+        "# from nbdev.export import notebook2script\n",
+        "# notebook2script('app.ipynb')"
+      ]
+    }
+  ],
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "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",
+      "version": "3.12.0"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}

app.py

@@ -1,7 +1,41 @@
+from fastai.vision.all import load_learner
 import gradio as gr
 
-def greet(name):
-    return "Hello " + name + "!!"
+musical_instruments = (
+    'Bansuri',
+    'Harmonium',
+    'Pakhawaz',
+    'Santoor',
+    'Sarangi',
+    'Sarod',
+    'Shehnai',
+    'Sitar',
+    'Tabla',
+    'Tanpura'
+)
 
-iface = gr.Interface(fn=greet, inputs="text", outputs="text")
-iface.launch()
+model = load_learner(f"models/musical-instrument-recognizer-v6.pkl")
+
+def recognize_image(image):
+  pred, idx, probs = model.predict(image)
+  return dict(zip(musical_instruments, map(float, probs)))
+
+
+
+image = gr.inputs.Image(shape=(192,192))
+label = gr.outputs.Label()
+examples = [
+    'test_data/bansuri.jfif',
+    'test_data/harmonium.jfif',
+    'test_data/pakhawaj.jfif',
+    'test_data/santoor.jfif',
+    'test_data/sarengi.jfif',
+    'test_data/sarod.jfif',
+    'test_data/shehnai.jfif',
+    'test_data/sitar.jfif',
+    'test_data/tabla.jfif',
+    'test_data/tanpura.jfif'
+]
+
+iface = gr.Interface(fn=recognize_image, inputs = image, outputs= label, examples = examples)
+iface.launch(inline =False, share = True)

models/musical-instrument-recognizer-v6.pkl

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