diff --git "a/app.ipynb" "b/app.ipynb" new file mode 100644--- /dev/null +++ "b/app.ipynb" @@ -0,0 +1,811 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "34d9f73f-31a9-4d27-bea3-74191e122fcc", + "metadata": {}, + "outputs": [], + "source": [ + "#|default_export app" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "a9e68e9e-7d03-47d7-ac93-b8ff36d54017", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting jupyterlab-quarto\n", + " Obtaining dependency information for jupyterlab-quarto from https://files.pythonhosted.org/packages/7d/23/67b43d5d4b8b0aca29f6a626350c9490d753123ccf63395567d1f6a5e0aa/jupyterlab_quarto-0.2.8-py3-none-any.whl.metadata\n", + " Downloading jupyterlab_quarto-0.2.8-py3-none-any.whl.metadata (6.8 kB)\n", + "Downloading jupyterlab_quarto-0.2.8-py3-none-any.whl (909 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m909.8/909.8 kB\u001b[0m \u001b[31m11.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m00:01\u001b[0m\n", + "\u001b[?25hInstalling collected packages: jupyterlab-quarto\n", + "Successfully installed jupyterlab-quarto-0.2.8\n" + ] + } + ], + "source": [ + "!pip install jupyterlab-quarto" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "33ddc767-1522-4da4-9ac9-5eb523432196", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting package metadata (current_repodata.json): done\n", + "Solving environment: done\n", + "\n", + "\n", + "==> WARNING: A newer version of conda exists. <==\n", + " current version: 23.3.1\n", + " latest version: 23.7.3\n", + "\n", + "Please update conda by running\n", + "\n", + " $ conda update -n base -c conda-forge conda\n", + "\n", + "Or to minimize the number of packages updated during conda update use\n", + "\n", + " conda install conda=23.7.3\n", + "\n", + "\n", + "\n", + "## Package Plan ##\n", + "\n", + " environment location: /home/hetan/mambaforge/envs/test\n", + "\n", + " added / updated specs:\n", + " - conda=23.7.3\n", + "\n", + "\n", + "The following packages will be downloaded:\n", + "\n", + " package | build\n", + " ---------------------------|-----------------\n", + " conda-23.7.3 | py310hff52083_0 1006 KB conda-forge\n", + " pluggy-1.3.0 | pyhd8ed1ab_0 22 KB conda-forge\n", + " zstandard-0.19.0 | py310h5764c6d_0 655 KB conda-forge\n", + " ------------------------------------------------------------\n", + " Total: 1.6 MB\n", + "\n", + "The following NEW packages will be INSTALLED:\n", + "\n", + " boltons conda-forge/noarch::boltons-23.0.0-pyhd8ed1ab_0 \n", + " conda conda-forge/linux-64::conda-23.7.3-py310hff52083_0 \n", + " conda-package-han~ conda-forge/noarch::conda-package-handling-2.2.0-pyh38be061_0 \n", + " conda-package-str~ conda-forge/noarch::conda-package-streaming-0.9.0-pyhd8ed1ab_0 \n", + " jsonpatch conda-forge/noarch::jsonpatch-1.32-pyhd8ed1ab_0 \n", + " jsonpointer conda-forge/noarch::jsonpointer-2.0-py_0 \n", + " pluggy conda-forge/noarch::pluggy-1.3.0-pyhd8ed1ab_0 \n", + " pycosat conda-forge/linux-64::pycosat-0.6.4-py310h5764c6d_1 \n", + " ruamel.yaml conda-forge/linux-64::ruamel.yaml-0.17.32-py310h2372a71_0 \n", + " ruamel.yaml.clib conda-forge/linux-64::ruamel.yaml.clib-0.2.7-py310h1fa729e_1 \n", + " toolz conda-forge/noarch::toolz-0.12.0-pyhd8ed1ab_0 \n", + " zstandard conda-forge/linux-64::zstandard-0.19.0-py310h5764c6d_0 \n", + "\n", + "\n", + "\n", + "Downloading and Extracting Packages\n", + "pluggy-1.3.0 | 22 KB | | 0% \n", + "conda-23.7.3 | 1006 KB | | 0% \u001b[A\n", + "\n", + "pluggy-1.3.0 | 22 KB | ##########################8 | 73% \u001b[A\u001b[A\n", + "conda-23.7.3 | 1006 KB | 5 | 2% \u001b[A\n", + "\n", + "pluggy-1.3.0 | 22 KB | ##################################### | 100% \u001b[A\u001b[A\n", + "conda-23.7.3 | 1006 KB | #######6 | 21% \u001b[A\n", + "\n", + "zstandard-0.19.0 | 655 KB | ############6 | 34% \u001b[A\u001b[A\n", + "\n", + "zstandard-0.19.0 | 655 KB | ##################################### | 100% \u001b[A\u001b[A\n", + "\n", + "zstandard-0.19.0 | 655 KB | ##################################### | 100% \u001b[A\u001b[A\n", + "conda-23.7.3 | 1006 KB | ##################################### | 100% \u001b[A\n", + " \u001b[A\n", + " \u001b[A\n", + "\n", + " \u001b[A\u001b[A\n", + "Preparing transaction: done\n", + "Verifying transaction: done\n", + "Executing transaction: done\n" + ] + } + ], + "source": [ + "!conda install conda=23.7.3 -y" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "3fa4fabe-e905-44f9-9e74-eda82a40d880", + "metadata": {}, + "outputs": [], + "source": [ + "!nbdev_migrate" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "2eb6ec0a-66c5-4aa2-90fa-a3fa55b96613", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting gradio\n", + " Obtaining dependency information for gradio from https://files.pythonhosted.org/packages/df/e7/e0b548208ff5db6323ad974f094e9435adb0a377f35274196fb74adaf58a/gradio-3.41.2-py3-none-any.whl.metadata\n", + " Using cached gradio-3.41.2-py3-none-any.whl.metadata (17 kB)\n", + "Collecting aiofiles<24.0,>=22.0 (from gradio)\n", + " Obtaining dependency information for aiofiles<24.0,>=22.0 from https://files.pythonhosted.org/packages/c5/19/5af6804c4cc0fed83f47bff6e413a98a36618e7d40185cd36e69737f3b0e/aiofiles-23.2.1-py3-none-any.whl.metadata\n", + " Using cached aiofiles-23.2.1-py3-none-any.whl.metadata (9.7 kB)\n", + "Collecting altair<6.0,>=4.2.0 (from gradio)\n", + " Obtaining dependency information for altair<6.0,>=4.2.0 from https://files.pythonhosted.org/packages/2b/40/ff33821bca16cac30f8d9c3244ac961416f40bf2d3261a1250aabda33a6f/altair-5.1.0-py3-none-any.whl.metadata\n", + " Using cached altair-5.1.0-py3-none-any.whl.metadata (8.6 kB)\n", + "Collecting fastapi (from gradio)\n", + " Obtaining dependency information for fastapi from https://files.pythonhosted.org/packages/89/e1/5391318b8b35eb4873ea504ca5181a5569d8e499a0920a61ba7e29e8fc2a/fastapi-0.103.0-py3-none-any.whl.metadata\n", + " Using cached fastapi-0.103.0-py3-none-any.whl.metadata (24 kB)\n", + "Collecting ffmpy (from gradio)\n", + " Using cached ffmpy-0.3.1-py3-none-any.whl\n", + "Collecting gradio-client==0.5.0 (from gradio)\n", + " Obtaining dependency information for gradio-client==0.5.0 from https://files.pythonhosted.org/packages/fe/85/ec0323f39192c4bee04e8e06e64213aff816b9d1b61c3c8367e75b1c7e10/gradio_client-0.5.0-py3-none-any.whl.metadata\n", + " Using cached gradio_client-0.5.0-py3-none-any.whl.metadata (7.1 kB)\n", + "Collecting httpx (from gradio)\n", + " Obtaining dependency information for httpx from https://files.pythonhosted.org/packages/ec/91/e41f64f03d2a13aee7e8c819d82ee3aa7cdc484d18c0ae859742597d5aa0/httpx-0.24.1-py3-none-any.whl.metadata\n", + " Using cached httpx-0.24.1-py3-none-any.whl.metadata (7.4 kB)\n", + "Requirement already satisfied: huggingface-hub>=0.14.0 in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from gradio) (0.16.4)\n", + "Collecting importlib-resources<7.0,>=1.3 (from gradio)\n", + " Obtaining dependency information for importlib-resources<7.0,>=1.3 from https://files.pythonhosted.org/packages/25/d4/592f53ce2f8dde8be5720851bd0ab71cc2e76c55978e4163ef1ab7e389bb/importlib_resources-6.0.1-py3-none-any.whl.metadata\n", + " Using cached importlib_resources-6.0.1-py3-none-any.whl.metadata (4.0 kB)\n", + "Requirement already satisfied: jinja2<4.0 in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from gradio) (3.1.2)\n", + "Requirement already satisfied: markupsafe~=2.0 in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from gradio) (2.1.3)\n", + "Requirement already satisfied: matplotlib~=3.0 in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from gradio) (3.7.2)\n", + "Requirement already satisfied: numpy~=1.0 in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from gradio) (1.25.2)\n", + "Collecting orjson~=3.0 (from gradio)\n", + " Obtaining dependency information for orjson~=3.0 from https://files.pythonhosted.org/packages/34/7a/9ec6142fdab1749eacbab23c8a502cccb57f1985d764a5cfacad1d55a2de/orjson-3.9.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata\n", + " Using cached orjson-3.9.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (49 kB)\n", + "Requirement already satisfied: packaging in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from gradio) (23.1)\n", + "Requirement already satisfied: pandas<3.0,>=1.0 in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from gradio) (2.0.3)\n", + "Requirement already satisfied: pillow<11.0,>=8.0 in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from gradio) (10.0.0)\n", + "Requirement already satisfied: pydantic!=1.8,!=1.8.1,!=2.0.0,!=2.0.1,<3.0.0,>=1.7.4 in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from gradio) (2.3.0)\n", + "Collecting pydub (from gradio)\n", + " Using cached pydub-0.25.1-py2.py3-none-any.whl (32 kB)\n", + "Collecting python-multipart (from gradio)\n", + " Using cached python_multipart-0.0.6-py3-none-any.whl (45 kB)\n", + "Requirement already satisfied: pyyaml<7.0,>=5.0 in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from gradio) (6.0.1)\n", + "Requirement already satisfied: requests~=2.0 in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from gradio) (2.31.0)\n", + "Collecting semantic-version~=2.0 (from gradio)\n", + " Using cached semantic_version-2.10.0-py2.py3-none-any.whl (15 kB)\n", + "Requirement already satisfied: typing-extensions~=4.0 in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from gradio) (4.7.1)\n", + "Collecting uvicorn>=0.14.0 (from gradio)\n", + " Obtaining dependency information for uvicorn>=0.14.0 from https://files.pythonhosted.org/packages/79/96/b0882a1c3f7ef3dd86879e041212ae5b62b4bd352320889231cc735a8e8f/uvicorn-0.23.2-py3-none-any.whl.metadata\n", + " Using cached uvicorn-0.23.2-py3-none-any.whl.metadata (6.2 kB)\n", + "Collecting websockets<12.0,>=10.0 (from gradio)\n", + " Using cached websockets-11.0.3-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl (129 kB)\n", + "Requirement already satisfied: fsspec in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from gradio-client==0.5.0->gradio) (2023.6.0)\n", + "Requirement already satisfied: jsonschema>=3.0 in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from altair<6.0,>=4.2.0->gradio) (4.19.0)\n", + "Collecting toolz (from altair<6.0,>=4.2.0->gradio)\n", + " Downloading toolz-0.12.0-py3-none-any.whl (55 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m55.8/55.8 kB\u001b[0m \u001b[31m2.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: filelock in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from huggingface-hub>=0.14.0->gradio) (3.12.2)\n", + "Requirement already satisfied: tqdm>=4.42.1 in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from huggingface-hub>=0.14.0->gradio) (4.66.1)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from matplotlib~=3.0->gradio) (1.1.0)\n", + "Requirement already satisfied: cycler>=0.10 in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from matplotlib~=3.0->gradio) (0.11.0)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from matplotlib~=3.0->gradio) (4.42.1)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from matplotlib~=3.0->gradio) (1.4.5)\n", + "Requirement already satisfied: pyparsing<3.1,>=2.3.1 in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from matplotlib~=3.0->gradio) (3.0.9)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from matplotlib~=3.0->gradio) (2.8.2)\n", + "Requirement already satisfied: pytz>=2020.1 in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from pandas<3.0,>=1.0->gradio) (2023.3)\n", + "Requirement already satisfied: tzdata>=2022.1 in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from pandas<3.0,>=1.0->gradio) (2023.3)\n", + "Requirement already satisfied: annotated-types>=0.4.0 in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from pydantic!=1.8,!=1.8.1,!=2.0.0,!=2.0.1,<3.0.0,>=1.7.4->gradio) (0.5.0)\n", + "Requirement already satisfied: pydantic-core==2.6.3 in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from pydantic!=1.8,!=1.8.1,!=2.0.0,!=2.0.1,<3.0.0,>=1.7.4->gradio) (2.6.3)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from requests~=2.0->gradio) (3.2.0)\n", + "Requirement already satisfied: idna<4,>=2.5 in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from requests~=2.0->gradio) (3.4)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from requests~=2.0->gradio) (1.26.15)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from requests~=2.0->gradio) (2023.7.22)\n", + "Requirement already satisfied: click>=7.0 in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from uvicorn>=0.14.0->gradio) (8.1.7)\n", + "Collecting h11>=0.8 (from uvicorn>=0.14.0->gradio)\n", + " Using cached h11-0.14.0-py3-none-any.whl (58 kB)\n", + "Collecting starlette<0.28.0,>=0.27.0 (from fastapi->gradio)\n", + " Obtaining dependency information for starlette<0.28.0,>=0.27.0 from https://files.pythonhosted.org/packages/58/f8/e2cca22387965584a409795913b774235752be4176d276714e15e1a58884/starlette-0.27.0-py3-none-any.whl.metadata\n", + " Using cached starlette-0.27.0-py3-none-any.whl.metadata (5.8 kB)\n", + "Collecting httpcore<0.18.0,>=0.15.0 (from httpx->gradio)\n", + " Obtaining dependency information for httpcore<0.18.0,>=0.15.0 from https://files.pythonhosted.org/packages/94/2c/2bde7ff8dd2064395555220cbf7cba79991172bf5315a07eb3ac7688d9f1/httpcore-0.17.3-py3-none-any.whl.metadata\n", + " Using cached httpcore-0.17.3-py3-none-any.whl.metadata (18 kB)\n", + "Requirement already satisfied: sniffio in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from httpx->gradio) (1.3.0)\n", + "Requirement already satisfied: anyio<5.0,>=3.0 in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from httpcore<0.18.0,>=0.15.0->httpx->gradio) (3.7.1)\n", + "Requirement already satisfied: attrs>=22.2.0 in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from jsonschema>=3.0->altair<6.0,>=4.2.0->gradio) (23.1.0)\n", + "Requirement already satisfied: jsonschema-specifications>=2023.03.6 in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from jsonschema>=3.0->altair<6.0,>=4.2.0->gradio) (2023.7.1)\n", + "Requirement already satisfied: referencing>=0.28.4 in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from jsonschema>=3.0->altair<6.0,>=4.2.0->gradio) (0.30.2)\n", + "Requirement already satisfied: rpds-py>=0.7.1 in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from jsonschema>=3.0->altair<6.0,>=4.2.0->gradio) (0.9.2)\n", + "Requirement already satisfied: six>=1.5 in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from python-dateutil>=2.7->matplotlib~=3.0->gradio) (1.16.0)\n", + "Requirement already satisfied: exceptiongroup in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from anyio<5.0,>=3.0->httpcore<0.18.0,>=0.15.0->httpx->gradio) (1.1.3)\n", + "Using cached gradio-3.41.2-py3-none-any.whl (20.1 MB)\n", + "Using cached gradio_client-0.5.0-py3-none-any.whl (298 kB)\n", + "Using cached aiofiles-23.2.1-py3-none-any.whl (15 kB)\n", + "Using cached altair-5.1.0-py3-none-any.whl (520 kB)\n", + "Using cached importlib_resources-6.0.1-py3-none-any.whl (34 kB)\n", + "Using cached orjson-3.9.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (139 kB)\n", + "Using cached uvicorn-0.23.2-py3-none-any.whl (59 kB)\n", + "Using cached fastapi-0.103.0-py3-none-any.whl (66 kB)\n", + "Using cached httpx-0.24.1-py3-none-any.whl (75 kB)\n", + "Using cached httpcore-0.17.3-py3-none-any.whl (74 kB)\n", + "Using cached starlette-0.27.0-py3-none-any.whl (66 kB)\n", + "Installing collected packages: pydub, ffmpy, websockets, toolz, semantic-version, python-multipart, orjson, importlib-resources, h11, aiofiles, uvicorn, starlette, httpcore, httpx, fastapi, gradio-client, altair, gradio\n", + "Successfully installed aiofiles-23.2.1 altair-5.1.0 fastapi-0.103.0 ffmpy-0.3.1 gradio-3.41.2 gradio-client-0.5.0 h11-0.14.0 httpcore-0.17.3 httpx-0.24.1 importlib-resources-6.0.1 orjson-3.9.5 pydub-0.25.1 python-multipart-0.0.6 semantic-version-2.10.0 starlette-0.27.0 toolz-0.12.0 uvicorn-0.23.2 websockets-11.0.3\n" + ] + } + ], + "source": [ + "#|default_exp app\n", + "!pip install gradio" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "7c9ea4c2-32a9-4516-b106-094e0ecb8cda", + "metadata": {}, + "outputs": [], + "source": [ + "#|default_exp app\n", + "from fastai.vision.all import *\n", + "import gradio as gd" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "73dd82eb-4606-408d-aae1-24778f0f6737", + "metadata": {}, + "outputs": [ + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "PILImage mode=RGB size=192x108" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "im = PILImage.create('car.jpg')\n", + "im.thumbnail((192,192))\n", + "im" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "2f03a38e-0b08-4565-8ebf-3b710542649c", + "metadata": {}, + "outputs": [], + "source": [ + "#|export\n", + "learn = load_learner('export.pkl')" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "337f7d74-8700-472a-8c00-2cff904bcf3a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 2.12 s, sys: 1.13 s, total: 3.25 s\n", + "Wall time: 281 ms\n" + ] + }, + { + "data": { + "text/plain": [ + "('car', tensor(0), tensor([0.9987, 0.0013]))" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%time learn.predict(im)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "25e7f043-efc3-465d-86b5-86c9abbad361", + "metadata": {}, + "outputs": [], + "source": [ + "#|export\n", + "categories = ('car','motorbike')\n", + "\n", + "def classify_images(img):\n", + " pred,idx,probs = learn.predict(img)\n", + " return dict(zip(categories,map(float,probs)))" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "ba2414c2-c98b-4e56-9ca8-868884145a61", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "{'car': 0.9987383484840393, 'motorbike': 0.0012616905150935054}" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "classify_images(im)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "00a02be3-737f-47a8-b08e-5a22589fd4f5", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_5396/3033771971.py:1: GradioDeprecationWarning: Usage of gradio.inputs is deprecated, and will not be supported in the future, please import your component from gradio.components\n", + " image = gd.inputs.Image(shape=(192,192))\n", + "/tmp/ipykernel_5396/3033771971.py:1: GradioDeprecationWarning: `optional` parameter is deprecated, and it has no effect\n", + " image = gd.inputs.Image(shape=(192,192))\n", + "/tmp/ipykernel_5396/3033771971.py:2: GradioDeprecationWarning: Usage of gradio.outputs is deprecated, and will not be supported in the future, please import your components from gradio.components\n", + " label = gd.outputs.Label()\n", + "/tmp/ipykernel_5396/3033771971.py:2: GradioUnusedKwargWarning: You have unused kwarg parameters in Label, please remove them: {'type': 'auto'}\n", + " label = gd.outputs.Label()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running on local URL: http://127.0.0.1:7861\n", + "\n", + "To create a public link, set `share=True` in `launch()`.\n" + ] + }, + { + "data": { + "text/plain": [] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/html": [ + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#|default_exp app\n", + "image = gd.inputs.Image(shape=(192,192))\n", + "label = gd.outputs.Label()\n", + "examples = ['car.jpg','bike.jpg']\n", + "\n", + "intf = gd.Interface(fn = classify_images,inputs = image, outputs = label, examples = examples)\n", + "intf.launch(inline=False)" + ] + }, + { + "cell_type": "markdown", + "id": "edca13b5-e819-4217-a719-63da9f7d4b89", + "metadata": {}, + "source": [ + "### Export" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "f428f1ce-637c-417f-97f0-f735a77ccd3b", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/hetan/mambaforge/envs/test/lib/python3.10/site-packages/nbdev/export.py:54: UserWarning: Notebook 'app.ipynb' uses `#|export` without `#|default_exp` cell.\n", + "Note nbdev2 no longer supports nbdev1 syntax. Run `nbdev_migrate` to upgrade.\n", + "See https://nbdev.fast.ai/getting_started.html for more information.\n", + " warn(f\"Notebook '{nbname}' uses `#|export` without `#|default_exp` cell.\\n\"\n" + ] + } + ], + "source": [ + "from nbdev.export import nb_export\n", + "nb_export('app.ipynb', '.')" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "8c091724-55b4-49e3-8572-2f13561a3a88", + "metadata": {}, + "outputs": [], + "source": [ + "from nbdev.export import nb_export\n", + "nb_export('app.ipynb')" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "c596a8f5-f970-404d-9c00-1b923f19ccba", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Traceback (most recent call last):\n", + " File \"/home/hetan/mambaforge/envs/test/bin/jupyter-nbconvert\", line 5, in \n", + " from nbconvert.nbconvertapp import main\n", + " File \"/home/hetan/mambaforge/envs/test/lib/python3.10/site-packages/nbconvert/nbconvertapp.py\", line 186, in \n", + " class NbConvertApp(JupyterApp):\n", + " File \"/home/hetan/mambaforge/envs/test/lib/python3.10/site-packages/nbconvert/nbconvertapp.py\", line 245, in NbConvertApp\n", + " Options include {get_export_names()}.\n", + " File \"/home/hetan/mambaforge/envs/test/lib/python3.10/site-packages/nbconvert/exporters/base.py\", line 151, in get_export_names\n", + " e = get_exporter(exporter_name)(config=config)\n", + " File \"/home/hetan/mambaforge/envs/test/lib/python3.10/site-packages/nbconvert/exporters/base.py\", line 110, in get_exporter\n", + " exporter = items[0].load()\n", + " File \"/home/hetan/mambaforge/envs/test/lib/python3.10/importlib/metadata/__init__.py\", line 171, in load\n", + " module = import_module(match.group('module'))\n", + " File \"/home/hetan/mambaforge/envs/test/lib/python3.10/importlib/__init__.py\", line 126, in import_module\n", + " return _bootstrap._gcd_import(name[level:], package, level)\n", + " File \"/home/hetan/mambaforge/envs/test/lib/python3.10/site-packages/jupyter_contrib_nbextensions/__init__.py\", line 5, in \n", + " import jupyter_nbextensions_configurator\n", + " File \"/home/hetan/mambaforge/envs/test/lib/python3.10/site-packages/jupyter_nbextensions_configurator/__init__.py\", line 18, in \n", + " from notebook.base.handlers import APIHandler, IPythonHandler\n", + "ModuleNotFoundError: No module named 'notebook.base'\n" + ] + } + ], + "source": [ + "!jupyter nbconvert --to script app.ipynb" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "6a84357a-e01a-4ddd-8770-3c59e85537db", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting jupytext\n", + " Obtaining dependency information for jupytext from https://files.pythonhosted.org/packages/d2/f5/d5f481cc9edb67c8d017a6eace529152ec496def175a87ce0aa158efc50e/jupytext-1.15.1-py3-none-any.whl.metadata\n", + " Downloading jupytext-1.15.1-py3-none-any.whl.metadata (9.7 kB)\n", + "Requirement already satisfied: nbformat in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from jupytext) (5.9.2)\n", + "Requirement already satisfied: pyyaml in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from jupytext) (6.0.1)\n", + "Requirement already satisfied: toml in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from jupytext) (0.10.2)\n", + "Requirement already satisfied: markdown-it-py>=1.0.0 in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from jupytext) (3.0.0)\n", + "Collecting mdit-py-plugins (from jupytext)\n", + " Obtaining dependency information for mdit-py-plugins from https://files.pythonhosted.org/packages/e5/3c/fe85f19699a7b40c8f9ce8ecee7e269b9b3c94099306df6f9891bdefeedd/mdit_py_plugins-0.4.0-py3-none-any.whl.metadata\n", + " Downloading mdit_py_plugins-0.4.0-py3-none-any.whl.metadata (2.7 kB)\n", + "Requirement already satisfied: mdurl~=0.1 in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from markdown-it-py>=1.0.0->jupytext) (0.1.0)\n", + "Requirement already satisfied: fastjsonschema in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from nbformat->jupytext) (2.18.0)\n", + "Requirement already satisfied: jsonschema>=2.6 in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from nbformat->jupytext) (4.19.0)\n", + "Requirement already satisfied: jupyter-core in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from nbformat->jupytext) (5.3.1)\n", + "Requirement already satisfied: traitlets>=5.1 in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from nbformat->jupytext) (5.9.0)\n", + "Requirement already satisfied: attrs>=22.2.0 in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from jsonschema>=2.6->nbformat->jupytext) (23.1.0)\n", + "Requirement already satisfied: jsonschema-specifications>=2023.03.6 in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from jsonschema>=2.6->nbformat->jupytext) (2023.7.1)\n", + "Requirement already satisfied: referencing>=0.28.4 in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from jsonschema>=2.6->nbformat->jupytext) (0.30.2)\n", + "Requirement already satisfied: rpds-py>=0.7.1 in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from jsonschema>=2.6->nbformat->jupytext) (0.9.2)\n", + "Requirement already satisfied: platformdirs>=2.5 in /home/hetan/mambaforge/envs/test/lib/python3.10/site-packages (from jupyter-core->nbformat->jupytext) (3.10.0)\n", + "Downloading jupytext-1.15.1-py3-none-any.whl (301 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m301.6/301.6 kB\u001b[0m \u001b[31m10.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading mdit_py_plugins-0.4.0-py3-none-any.whl (54 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m54.1/54.1 kB\u001b[0m \u001b[31m5.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hInstalling collected packages: mdit-py-plugins, jupytext\n", + "Successfully installed jupytext-1.15.1 mdit-py-plugins-0.4.0\n" + ] + } + ], + "source": [ + "!pip install jupytext" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "4149cf50-915c-46c5-b887-88597f4c21ff", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[jupytext] Reading app.ipynb in format ipynb\n", + "[jupytext] Writing app.py (destination file replaced)\n" + ] + } + ], + "source": [ + "!jupytext --to py app.ipynb " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0105bcb2-e68d-4922-90ea-44656206ac4d", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}