Add files using upload-large-folder tool

groundingLMM/gradio-dev/demo/Echocardiogram-Segmentation/requirements.txt

@@ -0,0 +1,7 @@
+-f https://download.pytorch.org/whl/torch_stable.html
+numpy
+matplotlib
+wget
+torch
+torchvision
+ 

groundingLMM/gradio-dev/demo/Echocardiogram-Segmentation/run.ipynb

@@ -0,0 +1 @@
+{"cells": [{"cell_type": "markdown", "id": 302934307671667531413257853548643485645, "metadata": {}, "source": ["# Gradio Demo: Echocardiogram-Segmentation"]}, {"cell_type": "code", "execution_count": null, "id": 272996653310673477252411125948039410165, "metadata": {}, "outputs": [], "source": ["!pip install -q gradio -f https://download.pytorch.org/whl/torch_stable.html numpy matplotlib wget torch torchvision   "]}, {"cell_type": "code", "execution_count": null, "id": 288918539441861185822528903084949547379, "metadata": {}, "outputs": [], "source": ["# Downloading files from the demo repo\n", "import os\n", "!wget -q https://github.com/gradio-app/gradio/raw/main/demo/Echocardiogram-Segmentation/img1.jpg\n", "!wget -q https://github.com/gradio-app/gradio/raw/main/demo/Echocardiogram-Segmentation/img2.jpg"]}, {"cell_type": "code", "execution_count": null, "id": 44380577570523278879349135829904343037, "metadata": {}, "outputs": [], "source": ["import os\n", "import numpy as np\n", "import torch\n", "import torchvision\n", "import wget \n", "\n", "\n", "destination_folder = \"output\"\n", "destination_for_weights = \"weights\"\n", "\n", "if os.path.exists(destination_for_weights):\n", "    print(\"The weights are at\", destination_for_weights)\n", "else:\n", "    print(\"Creating folder at \", destination_for_weights, \" to store weights\")\n", "    os.mkdir(destination_for_weights)\n", "    \n", "segmentationWeightsURL = 'https://github.com/douyang/EchoNetDynamic/releases/download/v1.0.0/deeplabv3_resnet50_random.pt'\n", "\n", "if not os.path.exists(os.path.join(destination_for_weights, os.path.basename(segmentationWeightsURL))):\n", "    print(\"Downloading Segmentation Weights, \", segmentationWeightsURL,\" to \",os.path.join(destination_for_weights, os.path.basename(segmentationWeightsURL)))\n", "    filename = wget.download(segmentationWeightsURL, out = destination_for_weights)\n", "else:\n", "    print(\"Segmentation Weights already present\")\n", "\n", "torch.cuda.empty_cache()\n", "\n", "def collate_fn(x):\n", "    x, f = zip(*x)\n", "    i = list(map(lambda t: t.shape[1], x))\n", "    x = torch.as_tensor(np.swapaxes(np.concatenate(x, 1), 0, 1))\n", "    return x, f, i\n", "\n", "model = torchvision.models.segmentation.deeplabv3_resnet50(pretrained=False, aux_loss=False)\n", "model.classifier[-1] = torch.nn.Conv2d(model.classifier[-1].in_channels, 1, kernel_size=model.classifier[-1].kernel_size)\n", "\n", "print(\"loading weights from \", os.path.join(destination_for_weights, \"deeplabv3_resnet50_random\"))\n", "\n", "if torch.cuda.is_available():\n", "    print(\"cuda is available, original weights\")\n", "    device = torch.device(\"cuda\")\n", "    model = torch.nn.DataParallel(model)\n", "    model.to(device)\n", "    checkpoint = torch.load(os.path.join(destination_for_weights, os.path.basename(segmentationWeightsURL)))\n", "    model.load_state_dict(checkpoint['state_dict'])\n", "else:\n", "    print(\"cuda is not available, cpu weights\")\n", "    device = torch.device(\"cpu\")\n", "    checkpoint = torch.load(os.path.join(destination_for_weights, os.path.basename(segmentationWeightsURL)), map_location = \"cpu\")\n", "    state_dict_cpu = {k[7:]: v for (k, v) in checkpoint['state_dict'].items()}\n", "    model.load_state_dict(state_dict_cpu)\n", "\n", "model.eval()\n", "\n", "def segment(input):\n", "    inp = input\n", "    x = inp.transpose([2, 0, 1])  #  channels-first\n", "    x = np.expand_dims(x, axis=0)  # adding a batch dimension    \n", "    \n", "    mean = x.mean(axis=(0, 2, 3))\n", "    std = x.std(axis=(0, 2, 3))\n", "    x = x - mean.reshape(1, 3, 1, 1)\n", "    x = x / std.reshape(1, 3, 1, 1)\n", "    \n", "    with torch.no_grad():\n", "        x = torch.from_numpy(x).type('torch.FloatTensor').to(device)\n", "        output = model(x)    \n", "    \n", "    y = output['out'].numpy()\n", "    y = y.squeeze()\n", "    \n", "    out = y>0    \n", "    \n", "    mask = inp.copy()\n", "    mask[out] = np.array([0, 0, 255])\n", "    \n", "    return mask\n", "\n", "import gradio as gr\n", "\n", "i = gr.Image(shape=(112, 112), label=\"Echocardiogram\")\n", "o = gr.Image(label=\"Segmentation Mask\")\n", "\n", "examples = [[\"img1.jpg\"], [\"img2.jpg\"]]\n", "title = None #\"Left Ventricle Segmentation\"\n", "description = \"This semantic segmentation model identifies the left ventricle in echocardiogram images.\"\n", "# videos. Accurate evaluation of the motion and size of the left ventricle is crucial for the assessment of cardiac function and ejection fraction. In this interface, the user inputs apical-4-chamber images from echocardiography videos and the model will output a prediction of the localization of the left ventricle in blue. This model was trained on the publicly released EchoNet-Dynamic dataset of 10k echocardiogram videos with 20k expert annotations of the left ventricle and published as part of \u2018Video-based AI for beat-to-beat assessment of cardiac function\u2019 by Ouyang et al. in Nature, 2020.\"\n", "thumbnail = \"https://raw.githubusercontent.com/gradio-app/hub-echonet/master/thumbnail.png\"\n", "gr.Interface(segment, i, o, examples=examples, allow_flagging=False, analytics_enabled=False, thumbnail=thumbnail, cache_examples=False).launch()\n"]}], "metadata": {}, "nbformat": 4, "nbformat_minor": 5}

groundingLMM/gradio-dev/demo/Echocardiogram-Segmentation/run.py

@@ -0,0 +1,88 @@
+import os
+import numpy as np
+import torch
+import torchvision
+import wget 
+
+
+destination_folder = "output"
+destination_for_weights = "weights"
+
+if os.path.exists(destination_for_weights):
+    print("The weights are at", destination_for_weights)
+else:
+    print("Creating folder at ", destination_for_weights, " to store weights")
+    os.mkdir(destination_for_weights)
+    
+segmentationWeightsURL = 'https://github.com/douyang/EchoNetDynamic/releases/download/v1.0.0/deeplabv3_resnet50_random.pt'
+
+if not os.path.exists(os.path.join(destination_for_weights, os.path.basename(segmentationWeightsURL))):
+    print("Downloading Segmentation Weights, ", segmentationWeightsURL," to ",os.path.join(destination_for_weights, os.path.basename(segmentationWeightsURL)))
+    filename = wget.download(segmentationWeightsURL, out = destination_for_weights)
+else:
+    print("Segmentation Weights already present")
+
+torch.cuda.empty_cache()
+
+def collate_fn(x):
+    x, f = zip(*x)
+    i = list(map(lambda t: t.shape[1], x))
+    x = torch.as_tensor(np.swapaxes(np.concatenate(x, 1), 0, 1))
+    return x, f, i
+
+model = torchvision.models.segmentation.deeplabv3_resnet50(pretrained=False, aux_loss=False)
+model.classifier[-1] = torch.nn.Conv2d(model.classifier[-1].in_channels, 1, kernel_size=model.classifier[-1].kernel_size)
+
+print("loading weights from ", os.path.join(destination_for_weights, "deeplabv3_resnet50_random"))
+
+if torch.cuda.is_available():
+    print("cuda is available, original weights")
+    device = torch.device("cuda")
+    model = torch.nn.DataParallel(model)
+    model.to(device)
+    checkpoint = torch.load(os.path.join(destination_for_weights, os.path.basename(segmentationWeightsURL)))
+    model.load_state_dict(checkpoint['state_dict'])
+else:
+    print("cuda is not available, cpu weights")
+    device = torch.device("cpu")
+    checkpoint = torch.load(os.path.join(destination_for_weights, os.path.basename(segmentationWeightsURL)), map_location = "cpu")
+    state_dict_cpu = {k[7:]: v for (k, v) in checkpoint['state_dict'].items()}
+    model.load_state_dict(state_dict_cpu)
+
+model.eval()
+
+def segment(input):
+    inp = input
+    x = inp.transpose([2, 0, 1])  #  channels-first
+    x = np.expand_dims(x, axis=0)  # adding a batch dimension    
+    
+    mean = x.mean(axis=(0, 2, 3))
+    std = x.std(axis=(0, 2, 3))
+    x = x - mean.reshape(1, 3, 1, 1)
+    x = x / std.reshape(1, 3, 1, 1)
+    
+    with torch.no_grad():
+        x = torch.from_numpy(x).type('torch.FloatTensor').to(device)
+        output = model(x)    
+    
+    y = output['out'].numpy()
+    y = y.squeeze()
+    
+    out = y>0    
+    
+    mask = inp.copy()
+    mask[out] = np.array([0, 0, 255])
+    
+    return mask
+
+import gradio as gr
+
+i = gr.Image(shape=(112, 112), label="Echocardiogram")
+o = gr.Image(label="Segmentation Mask")
+
+examples = [["img1.jpg"], ["img2.jpg"]]
+title = None #"Left Ventricle Segmentation"
+description = "This semantic segmentation model identifies the left ventricle in echocardiogram images."
+# videos. Accurate evaluation of the motion and size of the left ventricle is crucial for the assessment of cardiac function and ejection fraction. In this interface, the user inputs apical-4-chamber images from echocardiography videos and the model will output a prediction of the localization of the left ventricle in blue. This model was trained on the publicly released EchoNet-Dynamic dataset of 10k echocardiogram videos with 20k expert annotations of the left ventricle and published as part of ‘Video-based AI for beat-to-beat assessment of cardiac function’ by Ouyang et al. in Nature, 2020."
+thumbnail = "https://raw.githubusercontent.com/gradio-app/hub-echonet/master/thumbnail.png"
+gr.Interface(segment, i, o, examples=examples, allow_flagging=False, analytics_enabled=False, thumbnail=thumbnail, cache_examples=False).launch()

groundingLMM/gradio-dev/demo/all_demos/run.py

@@ -0,0 +1,35 @@
+import importlib
+import gradio as gr
+import os
+import sys
+import copy
+import pathlib
+
+os.environ["GRADIO_ANALYTICS_ENABLED"] = "False"
+
+demo_dir = pathlib.Path(__file__).parent / "demos"
+
+
+all_demos = []
+demo_module = None
+for p in sorted(os.listdir("./demos")):
+    old_path = copy.deepcopy(sys.path)
+    sys.path = [os.path.join(demo_dir, p)] + sys.path
+    try:  # Some demos may not be runnable because of 429 timeouts, etc.
+        if demo_module is None:
+            demo_module = importlib.import_module(f"run")
+        else:
+            demo_module = importlib.reload(demo_module)
+        all_demos.append((p, demo_module.demo))
+    except Exception as e:
+        p = p + " ❌"
+        with gr.Blocks() as demo:
+            gr.Markdown(f"Error loading demo: {e}")
+        all_demos.append((p, demo))
+
+with gr.Blocks() as mega_demo:
+    for demo_name, demo in all_demos:
+        with gr.Tab(demo_name):
+            demo.render()
+
+mega_demo.queue().launch()

groundingLMM/gradio-dev/demo/altair_plot/requirements.txt

@@ -0,0 +1,2 @@
+altair
+vega_datasets

groundingLMM/gradio-dev/demo/altair_plot/run.ipynb

@@ -0,0 +1 @@
+{"cells": [{"cell_type": "markdown", "id": 302934307671667531413257853548643485645, "metadata": {}, "source": ["# Gradio Demo: altair_plot"]}, {"cell_type": "code", "execution_count": null, "id": 272996653310673477252411125948039410165, "metadata": {}, "outputs": [], "source": ["!pip install -q gradio altair vega_datasets"]}, {"cell_type": "code", "execution_count": null, "id": 288918539441861185822528903084949547379, "metadata": {}, "outputs": [], "source": ["import altair as alt\n", "import gradio as gr\n", "import numpy as np\n", "import pandas as pd\n", "from vega_datasets import data\n", "\n", "\n", "def make_plot(plot_type):\n", "    if plot_type == \"scatter_plot\":\n", "        cars = data.cars()\n", "        return alt.Chart(cars).mark_point().encode(\n", "            x='Horsepower',\n", "            y='Miles_per_Gallon',\n", "            color='Origin',\n", "        )\n", "    elif plot_type == \"heatmap\":\n", "        # Compute x^2 + y^2 across a 2D grid\n", "        x, y = np.meshgrid(range(-5, 5), range(-5, 5))\n", "        z = x ** 2 + y ** 2\n", "\n", "        # Convert this grid to columnar data expected by Altair\n", "        source = pd.DataFrame({'x': x.ravel(),\n", "                            'y': y.ravel(),\n", "                            'z': z.ravel()})\n", "        return alt.Chart(source).mark_rect().encode(\n", "            x='x:O',\n", "            y='y:O',\n", "            color='z:Q'\n", "        )\n", "    elif plot_type == \"us_map\":\n", "        states = alt.topo_feature(data.us_10m.url, 'states')\n", "        source = data.income.url\n", "\n", "        return alt.Chart(source).mark_geoshape().encode(\n", "            shape='geo:G',\n", "            color='pct:Q',\n", "            tooltip=['name:N', 'pct:Q'],\n", "            facet=alt.Facet('group:N', columns=2),\n", "        ).transform_lookup(\n", "            lookup='id',\n", "            from_=alt.LookupData(data=states, key='id'),\n", "            as_='geo'\n", "        ).properties(\n", "            width=300,\n", "            height=175,\n", "        ).project(\n", "            type='albersUsa'\n", "        )\n", "    elif plot_type == \"interactive_barplot\":\n", "        source = data.movies.url\n", "\n", "        pts = alt.selection(type=\"single\", encodings=['x'])\n", "\n", "        rect = alt.Chart(data.movies.url).mark_rect().encode(\n", "            alt.X('IMDB_Rating:Q', bin=True),\n", "            alt.Y('Rotten_Tomatoes_Rating:Q', bin=True),\n", "            alt.Color('count()',\n", "                scale=alt.Scale(scheme='greenblue'),\n", "                legend=alt.Legend(title='Total Records')\n", "            )\n", "        )\n", "\n", "        circ = rect.mark_point().encode(\n", "            alt.ColorValue('grey'),\n", "            alt.Size('count()',\n", "                legend=alt.Legend(title='Records in Selection')\n", "            )\n", "        ).transform_filter(\n", "            pts\n", "        )\n", "\n", "        bar = alt.Chart(source).mark_bar().encode(\n", "            x='Major_Genre:N',\n", "            y='count()',\n", "            color=alt.condition(pts, alt.ColorValue(\"steelblue\"), alt.ColorValue(\"grey\"))\n", "        ).properties(\n", "            width=550,\n", "            height=200\n", "        ).add_selection(pts)\n", "\n", "        plot = alt.vconcat(\n", "            rect + circ,\n", "            bar\n", "        ).resolve_legend(\n", "            color=\"independent\",\n", "            size=\"independent\"\n", "        )\n", "        return plot\n", "    elif plot_type == \"radial\":\n", "        source = pd.DataFrame({\"values\": [12, 23, 47, 6, 52, 19]})\n", "\n", "        base = alt.Chart(source).encode(\n", "            theta=alt.Theta(\"values:Q\", stack=True),\n", "            radius=alt.Radius(\"values\", scale=alt.Scale(type=\"sqrt\", zero=True, rangeMin=20)),\n", "            color=\"values:N\",\n", "        )\n", "\n", "        c1 = base.mark_arc(innerRadius=20, stroke=\"#fff\")\n", "\n", "        c2 = base.mark_text(radiusOffset=10).encode(text=\"values:Q\")\n", "\n", "        return c1 + c2\n", "    elif plot_type == \"multiline\":\n", "        source = data.stocks()\n", "\n", "        highlight = alt.selection(type='single', on='mouseover',\n", "                                fields=['symbol'], nearest=True)\n", "\n", "        base = alt.Chart(source).encode(\n", "            x='date:T',\n", "            y='price:Q',\n", "            color='symbol:N'\n", "        )\n", "\n", "        points = base.mark_circle().encode(\n", "            opacity=alt.value(0)\n", "        ).add_selection(\n", "            highlight\n", "        ).properties(\n", "            width=600\n", "        )\n", "\n", "        lines = base.mark_line().encode(\n", "            size=alt.condition(~highlight, alt.value(1), alt.value(3))\n", "        )\n", "\n", "        return points + lines\n", "\n", "\n", "with gr.Blocks() as demo:\n", "    button = gr.Radio(label=\"Plot type\",\n", "                      choices=['scatter_plot', 'heatmap', 'us_map',\n", "                               'interactive_barplot', \"radial\", \"multiline\"], value='scatter_plot')\n", "    plot = gr.Plot(label=\"Plot\")\n", "    button.change(make_plot, inputs=button, outputs=[plot])\n", "    demo.load(make_plot, inputs=[button], outputs=[plot])\n", "\n", "\n", "if __name__ == \"__main__\":\n", "    demo.launch()\n"]}], "metadata": {}, "nbformat": 4, "nbformat_minor": 5}

groundingLMM/gradio-dev/demo/altair_plot/run.py

@@ -0,0 +1,140 @@
+import altair as alt
+import gradio as gr
+import numpy as np
+import pandas as pd
+from vega_datasets import data
+
+
+def make_plot(plot_type):
+    if plot_type == "scatter_plot":
+        cars = data.cars()
+        return alt.Chart(cars).mark_point().encode(
+            x='Horsepower',
+            y='Miles_per_Gallon',
+            color='Origin',
+        )
+    elif plot_type == "heatmap":
+        # Compute x^2 + y^2 across a 2D grid
+        x, y = np.meshgrid(range(-5, 5), range(-5, 5))
+        z = x ** 2 + y ** 2
+
+        # Convert this grid to columnar data expected by Altair
+        source = pd.DataFrame({'x': x.ravel(),
+                            'y': y.ravel(),
+                            'z': z.ravel()})
+        return alt.Chart(source).mark_rect().encode(
+            x='x:O',
+            y='y:O',
+            color='z:Q'
+        )
+    elif plot_type == "us_map":
+        states = alt.topo_feature(data.us_10m.url, 'states')
+        source = data.income.url
+
+        return alt.Chart(source).mark_geoshape().encode(
+            shape='geo:G',
+            color='pct:Q',
+            tooltip=['name:N', 'pct:Q'],
+            facet=alt.Facet('group:N', columns=2),
+        ).transform_lookup(
+            lookup='id',
+            from_=alt.LookupData(data=states, key='id'),
+            as_='geo'
+        ).properties(
+            width=300,
+            height=175,
+        ).project(
+            type='albersUsa'
+        )
+    elif plot_type == "interactive_barplot":
+        source = data.movies.url
+
+        pts = alt.selection(type="single", encodings=['x'])
+
+        rect = alt.Chart(data.movies.url).mark_rect().encode(
+            alt.X('IMDB_Rating:Q', bin=True),
+            alt.Y('Rotten_Tomatoes_Rating:Q', bin=True),
+            alt.Color('count()',
+                scale=alt.Scale(scheme='greenblue'),
+                legend=alt.Legend(title='Total Records')
+            )
+        )
+
+        circ = rect.mark_point().encode(
+            alt.ColorValue('grey'),
+            alt.Size('count()',
+                legend=alt.Legend(title='Records in Selection')
+            )
+        ).transform_filter(
+            pts
+        )
+
+        bar = alt.Chart(source).mark_bar().encode(
+            x='Major_Genre:N',
+            y='count()',
+            color=alt.condition(pts, alt.ColorValue("steelblue"), alt.ColorValue("grey"))
+        ).properties(
+            width=550,
+            height=200
+        ).add_selection(pts)
+
+        plot = alt.vconcat(
+            rect + circ,
+            bar
+        ).resolve_legend(
+            color="independent",
+            size="independent"
+        )
+        return plot
+    elif plot_type == "radial":
+        source = pd.DataFrame({"values": [12, 23, 47, 6, 52, 19]})
+
+        base = alt.Chart(source).encode(
+            theta=alt.Theta("values:Q", stack=True),
+            radius=alt.Radius("values", scale=alt.Scale(type="sqrt", zero=True, rangeMin=20)),
+            color="values:N",
+        )
+
+        c1 = base.mark_arc(innerRadius=20, stroke="#fff")
+
+        c2 = base.mark_text(radiusOffset=10).encode(text="values:Q")
+
+        return c1 + c2
+    elif plot_type == "multiline":
+        source = data.stocks()
+
+        highlight = alt.selection(type='single', on='mouseover',
+                                fields=['symbol'], nearest=True)
+
+        base = alt.Chart(source).encode(
+            x='date:T',
+            y='price:Q',
+            color='symbol:N'
+        )
+
+        points = base.mark_circle().encode(
+            opacity=alt.value(0)
+        ).add_selection(
+            highlight
+        ).properties(
+            width=600
+        )
+
+        lines = base.mark_line().encode(
+            size=alt.condition(~highlight, alt.value(1), alt.value(3))
+        )
+
+        return points + lines
+
+
+with gr.Blocks() as demo:
+    button = gr.Radio(label="Plot type",
+                      choices=['scatter_plot', 'heatmap', 'us_map',
+                               'interactive_barplot', "radial", "multiline"], value='scatter_plot')
+    plot = gr.Plot(label="Plot")
+    button.change(make_plot, inputs=button, outputs=[plot])
+    demo.load(make_plot, inputs=[button], outputs=[plot])
+
+
+if __name__ == "__main__":
+    demo.launch()

groundingLMM/gradio-dev/demo/blocks_component_shortcut/run.ipynb

@@ -0,0 +1 @@
+{"cells": [{"cell_type": "markdown", "id": 302934307671667531413257853548643485645, "metadata": {}, "source": ["# Gradio Demo: blocks_component_shortcut"]}, {"cell_type": "code", "execution_count": null, "id": 272996653310673477252411125948039410165, "metadata": {}, "outputs": [], "source": ["!pip install -q gradio "]}, {"cell_type": "code", "execution_count": null, "id": 288918539441861185822528903084949547379, "metadata": {}, "outputs": [], "source": ["import gradio as gr\n", "\n", "\n", "def greet(str):\n", "    return str\n", "\n", "\n", "with gr.Blocks() as demo:\n", "    \"\"\"\n", "    You can make use of str shortcuts you use in Interface within Blocks as well.\n", "    \n", "    Interface shortcut example:\n", "    Interface(greet, \"textarea\", \"textarea\")\n", "    \n", "    You can use \n", "    1. gr.component()\n", "    2. gr.templates.Template()\n", "    3. gr.Template()\n", "    All the templates are listed in gradio/templates.py\n", "    \"\"\"\n", "    with gr.Row():\n", "            text1 = gr.component(\"textarea\")\n", "            text2 = gr.TextArea()\n", "            text3 = gr.templates.TextArea()\n", "    text1.blur(greet, text1, text2)\n", "    text2.blur(greet, text2, text3)\n", "    text3.blur(greet, text3, text1)\n", "    button = gr.component(\"button\")\n", "\n", "if __name__ == \"__main__\":\n", "    demo.launch()\n"]}], "metadata": {}, "nbformat": 4, "nbformat_minor": 5}

groundingLMM/gradio-dev/demo/blocks_gpt/run.ipynb

@@ -0,0 +1 @@
+{"cells": [{"cell_type": "markdown", "id": 302934307671667531413257853548643485645, "metadata": {}, "source": ["# Gradio Demo: blocks_gpt"]}, {"cell_type": "code", "execution_count": null, "id": 272996653310673477252411125948039410165, "metadata": {}, "outputs": [], "source": ["!pip install -q gradio "]}, {"cell_type": "code", "execution_count": null, "id": 288918539441861185822528903084949547379, "metadata": {}, "outputs": [], "source": ["import gradio as gr\n", "\n", "api = gr.load(\"huggingface/EleutherAI/gpt-j-6B\")\n", "\n", "def complete_with_gpt(text):\n", "    # Use the last 50 characters of the text as context\n", "    return text[:-50] + api(text[-50:])\n", "\n", "with gr.Blocks() as demo:\n", "    textbox = gr.Textbox(placeholder=\"Type here and press enter...\", lines=4)\n", "    btn = gr.Button(\"Generate\")\n", "    \n", "    btn.click(complete_with_gpt, textbox, textbox)\n", "    \n", "if __name__ == \"__main__\":\n", "    demo.launch()"]}], "metadata": {}, "nbformat": 4, "nbformat_minor": 5}

groundingLMM/gradio-dev/demo/blocks_gpt/run.py

@@ -0,0 +1,16 @@
+import gradio as gr
+
+api = gr.load("huggingface/EleutherAI/gpt-j-6B")
+
+def complete_with_gpt(text):
+    # Use the last 50 characters of the text as context
+    return text[:-50] + api(text[-50:])
+
+with gr.Blocks() as demo:
+    textbox = gr.Textbox(placeholder="Type here and press enter...", lines=4)
+    btn = gr.Button("Generate")
+    
+    btn.click(complete_with_gpt, textbox, textbox)
+    
+if __name__ == "__main__":
+    demo.launch()

groundingLMM/gradio-dev/demo/blocks_xray/run.ipynb

@@ -0,0 +1 @@
+{"cells": [{"cell_type": "markdown", "id": 302934307671667531413257853548643485645, "metadata": {}, "source": ["# Gradio Demo: blocks_xray"]}, {"cell_type": "code", "execution_count": null, "id": 272996653310673477252411125948039410165, "metadata": {}, "outputs": [], "source": ["!pip install -q gradio "]}, {"cell_type": "code", "execution_count": null, "id": 288918539441861185822528903084949547379, "metadata": {}, "outputs": [], "source": ["import gradio as gr\n", "import random\n", "import time\n", "\n", "def xray_model(diseases, img):\n", "    time.sleep(4)\n", "    return [{disease: random.random() for disease in diseases}]\n", "\n", "\n", "def ct_model(diseases, img):\n", "    time.sleep(3)\n", "    return [{disease: 0.1 for disease in diseases}]\n", "\n", "with gr.Blocks() as demo:\n", "    gr.Markdown(\n", "        \"\"\"\n", "# Detect Disease From Scan\n", "With this model you can lorem ipsum\n", "- ipsum 1\n", "- ipsum 2\n", "\"\"\"\n", "    )\n", "    disease = gr.CheckboxGroup(\n", "        info=\"Select the diseases you want to scan for.\",\n", "        choices=[\"Covid\", \"Malaria\", \"Lung Cancer\"], label=\"Disease to Scan For\"\n", "    )\n", "    slider = gr.Slider(0, 100)\n", "\n", "    with gr.Tab(\"X-ray\") as x_tab:\n", "        with gr.Row():\n", "            xray_scan = gr.Image()\n", "            xray_results = gr.JSON()\n", "        xray_run = gr.Button(\"Run\")\n", "        xray_run.click(\n", "            xray_model,\n", "            inputs=[disease, xray_scan],\n", "            outputs=xray_results,\n", "            api_name=\"xray_model\"\n", "        )\n", "\n", "    with gr.Tab(\"CT Scan\"):\n", "        with gr.Row():\n", "            ct_scan = gr.Image()\n", "            ct_results = gr.JSON()\n", "        ct_run = gr.Button(\"Run\")\n", "        ct_run.click(\n", "            ct_model,\n", "            inputs=[disease, ct_scan],\n", "            outputs=ct_results,\n", "            api_name=\"ct_model\"\n", "        )\n", "\n", "    upload_btn = gr.Button(\"Upload Results\", variant=\"primary\")\n", "    upload_btn.click(\n", "        lambda ct, xr: time.sleep(5),\n", "        inputs=[ct_results, xray_results],\n", "        outputs=[],\n", "    )\n", "\n", "if __name__ == \"__main__\":\n", "    demo.launch()\n"]}], "metadata": {}, "nbformat": 4, "nbformat_minor": 5}

groundingLMM/gradio-dev/demo/blocks_xray/run.py

@@ -0,0 +1,61 @@
+import gradio as gr
+import random
+import time
+
+def xray_model(diseases, img):
+    time.sleep(4)
+    return [{disease: random.random() for disease in diseases}]
+
+
+def ct_model(diseases, img):
+    time.sleep(3)
+    return [{disease: 0.1 for disease in diseases}]
+
+with gr.Blocks() as demo:
+    gr.Markdown(
+        """
+# Detect Disease From Scan
+With this model you can lorem ipsum
+- ipsum 1
+- ipsum 2
+"""
+    )
+    disease = gr.CheckboxGroup(
+        info="Select the diseases you want to scan for.",
+        choices=["Covid", "Malaria", "Lung Cancer"], label="Disease to Scan For"
+    )
+    slider = gr.Slider(0, 100)
+
+    with gr.Tab("X-ray") as x_tab:
+        with gr.Row():
+            xray_scan = gr.Image()
+            xray_results = gr.JSON()
+        xray_run = gr.Button("Run")
+        xray_run.click(
+            xray_model,
+            inputs=[disease, xray_scan],
+            outputs=xray_results,
+            api_name="xray_model"
+        )
+
+    with gr.Tab("CT Scan"):
+        with gr.Row():
+            ct_scan = gr.Image()
+            ct_results = gr.JSON()
+        ct_run = gr.Button("Run")
+        ct_run.click(
+            ct_model,
+            inputs=[disease, ct_scan],
+            outputs=ct_results,
+            api_name="ct_model"
+        )
+
+    upload_btn = gr.Button("Upload Results", variant="primary")
+    upload_btn.click(
+        lambda ct, xr: time.sleep(5),
+        inputs=[ct_results, xray_results],
+        outputs=[],
+    )
+
+if __name__ == "__main__":
+    demo.launch()

groundingLMM/gradio-dev/demo/calculator/run.ipynb

@@ -0,0 +1 @@
+{"cells": [{"cell_type": "markdown", "id": 302934307671667531413257853548643485645, "metadata": {}, "source": ["# Gradio Demo: calculator"]}, {"cell_type": "code", "execution_count": null, "id": 272996653310673477252411125948039410165, "metadata": {}, "outputs": [], "source": ["!pip install -q gradio "]}, {"cell_type": "code", "execution_count": null, "id": 288918539441861185822528903084949547379, "metadata": {}, "outputs": [], "source": ["# Downloading files from the demo repo\n", "import os\n", "os.mkdir('examples')\n", "!wget -q -O examples/log.csv https://github.com/gradio-app/gradio/raw/main/demo/calculator/examples/log.csv"]}, {"cell_type": "code", "execution_count": null, "id": 44380577570523278879349135829904343037, "metadata": {}, "outputs": [], "source": ["import gradio as gr\n", "\n", "def calculator(num1, operation, num2):\n", "    if operation == \"add\":\n", "        return num1 + num2\n", "    elif operation == \"subtract\":\n", "        return num1 - num2\n", "    elif operation == \"multiply\":\n", "        return num1 * num2\n", "    elif operation == \"divide\":\n", "        if num2 == 0:\n", "            raise gr.Error(\"Cannot divide by zero!\")\n", "        return num1 / num2\n", "\n", "demo = gr.Interface(\n", "    calculator,\n", "    [\n", "        \"number\", \n", "        gr.Radio([\"add\", \"subtract\", \"multiply\", \"divide\"]),\n", "        \"number\"\n", "    ],\n", "    \"number\",\n", "    examples=[\n", "        [5, \"add\", 3],\n", "        [4, \"divide\", 2],\n", "        [-4, \"multiply\", 2.5],\n", "        [0, \"subtract\", 1.2],\n", "    ],\n", "    title=\"Toy Calculator\",\n", "    description=\"Here's a sample toy calculator. Allows you to calculate things like $2+2=4$\",\n", ")\n", "if __name__ == \"__main__\":\n", "    demo.launch()\n"]}], "metadata": {}, "nbformat": 4, "nbformat_minor": 5}

groundingLMM/gradio-dev/demo/calculator/run.py

@@ -0,0 +1,33 @@
+import gradio as gr
+
+def calculator(num1, operation, num2):
+    if operation == "add":
+        return num1 + num2
+    elif operation == "subtract":
+        return num1 - num2
+    elif operation == "multiply":
+        return num1 * num2
+    elif operation == "divide":
+        if num2 == 0:
+            raise gr.Error("Cannot divide by zero!")
+        return num1 / num2
+
+demo = gr.Interface(
+    calculator,
+    [
+        "number", 
+        gr.Radio(["add", "subtract", "multiply", "divide"]),
+        "number"
+    ],
+    "number",
+    examples=[
+        [5, "add", 3],
+        [4, "divide", 2],
+        [-4, "multiply", 2.5],
+        [0, "subtract", 1.2],
+    ],
+    title="Toy Calculator",
+    description="Here's a sample toy calculator. Allows you to calculate things like $2+2=4$",
+)
+if __name__ == "__main__":
+    demo.launch()

groundingLMM/gradio-dev/demo/calculator_live/run.ipynb

@@ -0,0 +1 @@
+{"cells": [{"cell_type": "markdown", "id": 302934307671667531413257853548643485645, "metadata": {}, "source": ["# Gradio Demo: calculator_live"]}, {"cell_type": "code", "execution_count": null, "id": 272996653310673477252411125948039410165, "metadata": {}, "outputs": [], "source": ["!pip install -q gradio "]}, {"cell_type": "code", "execution_count": null, "id": 288918539441861185822528903084949547379, "metadata": {}, "outputs": [], "source": ["import gradio as gr\n", "\n", "def calculator(num1, operation, num2):\n", "    if operation == \"add\":\n", "        return num1 + num2\n", "    elif operation == \"subtract\":\n", "        return num1 - num2\n", "    elif operation == \"multiply\":\n", "        return num1 * num2\n", "    elif operation == \"divide\":\n", "        return num1 / num2\n", "\n", "demo = gr.Interface(\n", "    calculator,\n", "    [\n", "        \"number\",\n", "        gr.Radio([\"add\", \"subtract\", \"multiply\", \"divide\"]),\n", "        \"number\"\n", "    ],\n", "    \"number\",\n", "    live=True,\n", ")\n", "if __name__ == \"__main__\":\n", "    demo.launch()\n"]}], "metadata": {}, "nbformat": 4, "nbformat_minor": 5}

groundingLMM/gradio-dev/demo/calculator_live/run.py

@@ -0,0 +1,24 @@
+import gradio as gr
+
+def calculator(num1, operation, num2):
+    if operation == "add":
+        return num1 + num2
+    elif operation == "subtract":
+        return num1 - num2
+    elif operation == "multiply":
+        return num1 * num2
+    elif operation == "divide":
+        return num1 / num2
+
+demo = gr.Interface(
+    calculator,
+    [
+        "number",
+        gr.Radio(["add", "subtract", "multiply", "divide"]),
+        "number"
+    ],
+    "number",
+    live=True,
+)
+if __name__ == "__main__":
+    demo.launch()

groundingLMM/gradio-dev/demo/cancel_events/run.ipynb

@@ -0,0 +1 @@
+{"cells": [{"cell_type": "markdown", "id": 302934307671667531413257853548643485645, "metadata": {}, "source": ["# Gradio Demo: cancel_events"]}, {"cell_type": "code", "execution_count": null, "id": 272996653310673477252411125948039410165, "metadata": {}, "outputs": [], "source": ["!pip install -q gradio "]}, {"cell_type": "code", "execution_count": null, "id": 288918539441861185822528903084949547379, "metadata": {}, "outputs": [], "source": ["import time\n", "import gradio as gr\n", "\n", "\n", "def fake_diffusion(steps):\n", "    for i in range(steps):\n", "        print(f\"Current step: {i}\")\n", "        time.sleep(1)\n", "        yield str(i)\n", "\n", "\n", "def long_prediction(*args, **kwargs):\n", "    time.sleep(10)\n", "    return 42\n", "\n", "\n", "with gr.Blocks() as demo:\n", "    with gr.Row():\n", "        with gr.Column():\n", "            n = gr.Slider(1, 10, value=9, step=1, label=\"Number Steps\")\n", "            run = gr.Button()\n", "            output = gr.Textbox(label=\"Iterative Output\")\n", "            stop = gr.Button(value=\"Stop Iterating\")\n", "        with gr.Column():\n", "            textbox = gr.Textbox(label=\"Prompt\")\n", "            prediction = gr.Number(label=\"Expensive Calculation\")\n", "            run_pred = gr.Button(value=\"Run Expensive Calculation\")\n", "        with gr.Column():\n", "            cancel_on_change = gr.Textbox(label=\"Cancel Iteration and Expensive Calculation on Change\")\n", "            cancel_on_submit = gr.Textbox(label=\"Cancel Iteration and Expensive Calculation on Submit\")\n", "            echo = gr.Textbox(label=\"Echo\")\n", "    with gr.Row():\n", "        with gr.Column():\n", "            image = gr.Image(source=\"webcam\", tool=\"editor\", label=\"Cancel on edit\", interactive=True)\n", "        with gr.Column():\n", "            video = gr.Video(source=\"webcam\", label=\"Cancel on play\", interactive=True)\n", "\n", "    click_event = run.click(fake_diffusion, n, output)\n", "    stop.click(fn=None, inputs=None, outputs=None, cancels=[click_event])\n", "    pred_event = run_pred.click(fn=long_prediction, inputs=[textbox], outputs=prediction)\n", "\n", "    cancel_on_change.change(None, None, None, cancels=[click_event, pred_event])\n", "    cancel_on_submit.submit(lambda s: s, cancel_on_submit, echo, cancels=[click_event, pred_event])\n", "    image.edit(None, None, None, cancels=[click_event, pred_event])\n", "    video.play(None, None, None, cancels=[click_event, pred_event])\n", "\n", "\n", "if __name__ == \"__main__\":\n", "    demo.queue(concurrency_count=2, max_size=20).launch()\n"]}], "metadata": {}, "nbformat": 4, "nbformat_minor": 5}

groundingLMM/gradio-dev/demo/cancel_events/run.py

@@ -0,0 +1,49 @@
+import time
+import gradio as gr
+
+
+def fake_diffusion(steps):
+    for i in range(steps):
+        print(f"Current step: {i}")
+        time.sleep(1)
+        yield str(i)
+
+
+def long_prediction(*args, **kwargs):
+    time.sleep(10)
+    return 42
+
+
+with gr.Blocks() as demo:
+    with gr.Row():
+        with gr.Column():
+            n = gr.Slider(1, 10, value=9, step=1, label="Number Steps")
+            run = gr.Button()
+            output = gr.Textbox(label="Iterative Output")
+            stop = gr.Button(value="Stop Iterating")
+        with gr.Column():
+            textbox = gr.Textbox(label="Prompt")
+            prediction = gr.Number(label="Expensive Calculation")
+            run_pred = gr.Button(value="Run Expensive Calculation")
+        with gr.Column():
+            cancel_on_change = gr.Textbox(label="Cancel Iteration and Expensive Calculation on Change")
+            cancel_on_submit = gr.Textbox(label="Cancel Iteration and Expensive Calculation on Submit")
+            echo = gr.Textbox(label="Echo")
+    with gr.Row():
+        with gr.Column():
+            image = gr.Image(source="webcam", tool="editor", label="Cancel on edit", interactive=True)
+        with gr.Column():
+            video = gr.Video(source="webcam", label="Cancel on play", interactive=True)
+
+    click_event = run.click(fake_diffusion, n, output)
+    stop.click(fn=None, inputs=None, outputs=None, cancels=[click_event])
+    pred_event = run_pred.click(fn=long_prediction, inputs=[textbox], outputs=prediction)
+
+    cancel_on_change.change(None, None, None, cancels=[click_event, pred_event])
+    cancel_on_submit.submit(lambda s: s, cancel_on_submit, echo, cancels=[click_event, pred_event])
+    image.edit(None, None, None, cancels=[click_event, pred_event])
+    video.play(None, None, None, cancels=[click_event, pred_event])
+
+
+if __name__ == "__main__":
+    demo.queue(concurrency_count=2, max_size=20).launch()

groundingLMM/gradio-dev/demo/chicago-bikeshare-dashboard/requirements.txt

@@ -0,0 +1,3 @@
+psycopg2
+matplotlib
+SQLAlchemy

groundingLMM/gradio-dev/demo/chicago-bikeshare-dashboard/run.ipynb

@@ -0,0 +1 @@
+{"cells": [{"cell_type": "markdown", "id": 302934307671667531413257853548643485645, "metadata": {}, "source": ["# Gradio Demo: chicago-bikeshare-dashboard"]}, {"cell_type": "code", "execution_count": null, "id": 272996653310673477252411125948039410165, "metadata": {}, "outputs": [], "source": ["!pip install -q gradio psycopg2 matplotlib SQLAlchemy "]}, {"cell_type": "code", "execution_count": null, "id": 288918539441861185822528903084949547379, "metadata": {}, "outputs": [], "source": ["import os\n", "import gradio as gr\n", "import pandas as pd\n", "\n", "DB_USER = os.getenv(\"DB_USER\")\n", "DB_PASSWORD = os.getenv(\"DB_PASSWORD\")\n", "DB_HOST = os.getenv(\"DB_HOST\")\n", "PORT = 8080\n", "DB_NAME = \"bikeshare\"\n", "\n", "connection_string = (\n", "    f\"postgresql://{DB_USER}:{DB_PASSWORD}@{DB_HOST}?port={PORT}&dbname={DB_NAME}\"\n", ")\n", "\n", "\n", "def get_count_ride_type():\n", "    df = pd.read_sql(\n", "        \"\"\"\n", "        SELECT COUNT(ride_id) as n, rideable_type\n", "        FROM rides\n", "        GROUP BY rideable_type\n", "        ORDER BY n DESC\n", "    \"\"\",\n", "        con=connection_string,\n", "    )\n", "    return df\n", "\n", "\n", "def get_most_popular_stations():\n", "\n", "    df = pd.read_sql(\n", "        \"\"\"\n", "    SELECT COUNT(ride_id) as n, MAX(start_station_name) as station\n", "    FROM RIDES\n", "    WHERE start_station_name is NOT NULL\n", "    GROUP BY start_station_id\n", "    ORDER BY n DESC\n", "    LIMIT 5\n", "    \"\"\",\n", "        con=connection_string,\n", "    )\n", "    return df\n", "\n", "\n", "with gr.Blocks() as demo:\n", "    gr.Markdown(\n", "        \"\"\"\n", "    # Chicago Bike Share Dashboard\n", "    \n", "    This demo pulls Chicago bike share data for March 2022 from a postgresql database hosted on AWS.\n", "    This demo uses psycopg2 but any postgresql client library (SQLAlchemy)\n", "    is compatible with gradio.\n", "    \n", "    Connection credentials are handled by environment variables\n", "    defined as secrets in the Space.\n", "\n", "    If data were added to the database, the plots in this demo would update\n", "    whenever the webpage is reloaded.\n", "    \n", "    This demo serves as a starting point for your database-connected apps!\n", "    \"\"\"\n", "    )\n", "    with gr.Row():\n", "        bike_type = gr.BarPlot(\n", "            x=\"rideable_type\",\n", "            y='n',\n", "            title=\"Number of rides per bicycle type\",\n", "            y_title=\"Number of Rides\",\n", "            x_title=\"Bicycle Type\",\n", "            vertical=False,\n", "            tooltip=['rideable_type', \"n\"],\n", "            height=300,\n", "            width=300,\n", "        )\n", "        station = gr.BarPlot(\n", "            x='station',\n", "            y='n',\n", "            title=\"Most Popular Stations\",\n", "            y_title=\"Number of Rides\",\n", "            x_title=\"Station Name\",\n", "            vertical=False,\n", "            tooltip=['station', 'n'],\n", "            height=300,\n", "            width=300\n", "        )\n", "\n", "    demo.load(get_count_ride_type, inputs=None, outputs=bike_type)\n", "    demo.load(get_most_popular_stations, inputs=None, outputs=station)\n", "\n", "if __name__ == \"__main__\":\n", "    demo.launch()\n"]}], "metadata": {}, "nbformat": 4, "nbformat_minor": 5}

groundingLMM/gradio-dev/demo/chicago-bikeshare-dashboard/run.py

@@ -0,0 +1,91 @@
+import os
+import gradio as gr
+import pandas as pd
+
+DB_USER = os.getenv("DB_USER")
+DB_PASSWORD = os.getenv("DB_PASSWORD")
+DB_HOST = os.getenv("DB_HOST")
+PORT = 8080
+DB_NAME = "bikeshare"
+
+connection_string = (
+    f"postgresql://{DB_USER}:{DB_PASSWORD}@{DB_HOST}?port={PORT}&dbname={DB_NAME}"
+)
+
+
+def get_count_ride_type():
+    df = pd.read_sql(
+        """
+        SELECT COUNT(ride_id) as n, rideable_type
+        FROM rides
+        GROUP BY rideable_type
+        ORDER BY n DESC
+    """,
+        con=connection_string,
+    )
+    return df
+
+
+def get_most_popular_stations():
+
+    df = pd.read_sql(
+        """
+    SELECT COUNT(ride_id) as n, MAX(start_station_name) as station
+    FROM RIDES
+    WHERE start_station_name is NOT NULL
+    GROUP BY start_station_id
+    ORDER BY n DESC
+    LIMIT 5
+    """,
+        con=connection_string,
+    )
+    return df
+
+
+with gr.Blocks() as demo:
+    gr.Markdown(
+        """
+    # Chicago Bike Share Dashboard
+    
+    This demo pulls Chicago bike share data for March 2022 from a postgresql database hosted on AWS.
+    This demo uses psycopg2 but any postgresql client library (SQLAlchemy)
+    is compatible with gradio.
+    
+    Connection credentials are handled by environment variables
+    defined as secrets in the Space.
+
+    If data were added to the database, the plots in this demo would update
+    whenever the webpage is reloaded.
+    
+    This demo serves as a starting point for your database-connected apps!
+    """
+    )
+    with gr.Row():
+        bike_type = gr.BarPlot(
+            x="rideable_type",
+            y='n',
+            title="Number of rides per bicycle type",
+            y_title="Number of Rides",
+            x_title="Bicycle Type",
+            vertical=False,
+            tooltip=['rideable_type', "n"],
+            height=300,
+            width=300,
+        )
+        station = gr.BarPlot(
+            x='station',
+            y='n',
+            title="Most Popular Stations",
+            y_title="Number of Rides",
+            x_title="Station Name",
+            vertical=False,
+            tooltip=['station', 'n'],
+            height=300,
+            width=300
+        )
+
+    demo.load(get_count_ride_type, inputs=None, outputs=bike_type)
+    demo.load(get_most_popular_stations, inputs=None, outputs=station)
+
+if __name__ == "__main__":
+    demo.launch()

groundingLMM/gradio-dev/demo/colorpicker_component/run.ipynb

@@ -0,0 +1 @@
+{"cells": [{"cell_type": "markdown", "id": 302934307671667531413257853548643485645, "metadata": {}, "source": ["# Gradio Demo: colorpicker_component"]}, {"cell_type": "code", "execution_count": null, "id": 272996653310673477252411125948039410165, "metadata": {}, "outputs": [], "source": ["!pip install -q gradio "]}, {"cell_type": "code", "execution_count": null, "id": 288918539441861185822528903084949547379, "metadata": {}, "outputs": [], "source": ["import gradio as gr \n", "\n", "css = \"footer {display: none !important;} .gradio-container {min-height: 0px !important;}\"\n", "\n", "with gr.Blocks(css=css) as demo:\n", "    gr.ColorPicker()\n", "\n", "demo.launch()"]}], "metadata": {}, "nbformat": 4, "nbformat_minor": 5}

groundingLMM/gradio-dev/demo/colorpicker_component/run.py

@@ -0,0 +1,8 @@
+import gradio as gr 
+
+css = "footer {display: none !important;} .gradio-container {min-height: 0px !important;}"
+
+with gr.Blocks(css=css) as demo:
+    gr.ColorPicker()
+
+demo.launch()

groundingLMM/gradio-dev/demo/depth_estimation/DESCRIPTION.md

@@ -0,0 +1 @@
+A demo for predicting the depth of an image and generating a 3D model of it.

groundingLMM/gradio-dev/demo/depth_estimation/packages.txt

@@ -0,0 +1 @@
+libgl1-mesa-glx

groundingLMM/gradio-dev/demo/depth_estimation/requirements.txt

@@ -0,0 +1,6 @@
+torch
+git+https://github.com/nielsrogge/transformers.git@add_dpt_redesign#egg=transformers
+numpy
+Pillow
+jinja2
+open3d

groundingLMM/gradio-dev/demo/depth_estimation/run.ipynb

@@ -0,0 +1 @@
+{"cells": [{"cell_type": "markdown", "id": 302934307671667531413257853548643485645, "metadata": {}, "source": ["# Gradio Demo: depth_estimation\n", "### A demo for predicting the depth of an image and generating a 3D model of it.\n", "        "]}, {"cell_type": "code", "execution_count": null, "id": 272996653310673477252411125948039410165, "metadata": {}, "outputs": [], "source": ["!pip install -q gradio torch git+https://github.com/nielsrogge/transformers.git@add_dpt_redesign#egg=transformers numpy Pillow jinja2 open3d"]}, {"cell_type": "code", "execution_count": null, "id": 288918539441861185822528903084949547379, "metadata": {}, "outputs": [], "source": ["# Downloading files from the demo repo\n", "import os\n", "os.mkdir('examples')\n", "!wget -q -O examples/1-jonathan-borba-CgWTqYxHEkg-unsplash.jpg https://github.com/gradio-app/gradio/raw/main/demo/depth_estimation/examples/1-jonathan-borba-CgWTqYxHEkg-unsplash.jpg\n", "!wget -q https://github.com/gradio-app/gradio/raw/main/demo/depth_estimation/packages.txt"]}, {"cell_type": "code", "execution_count": null, "id": 44380577570523278879349135829904343037, "metadata": {}, "outputs": [], "source": ["import gradio as gr\n", "from transformers import DPTFeatureExtractor, DPTForDepthEstimation\n", "import torch\n", "import numpy as np\n", "from PIL import Image\n", "import open3d as o3d\n", "from pathlib import Path\n", "\n", "feature_extractor = DPTFeatureExtractor.from_pretrained(\"Intel/dpt-large\")\n", "model = DPTForDepthEstimation.from_pretrained(\"Intel/dpt-large\")\n", "\n", "def process_image(image_path):\n", "    image_path = Path(image_path)\n", "    image_raw = Image.open(image_path)\n", "    image = image_raw.resize(\n", "        (800, int(800 * image_raw.size[1] / image_raw.size[0])),\n", "        Image.Resampling.LANCZOS)\n", "\n", "    # prepare image for the model\n", "    encoding = feature_extractor(image, return_tensors=\"pt\")\n", "\n", "    # forward pass\n", "    with torch.no_grad():\n", "        outputs = model(**encoding)\n", "        predicted_depth = outputs.predicted_depth\n", "\n", "    # interpolate to original size\n", "    prediction = torch.nn.functional.interpolate(\n", "        predicted_depth.unsqueeze(1),\n", "        size=image.size[::-1],\n", "        mode=\"bicubic\",\n", "        align_corners=False,\n", "    ).squeeze()\n", "    output = prediction.cpu().numpy()\n", "    depth_image = (output * 255 / np.max(output)).astype('uint8')\n", "    try:\n", "        gltf_path = create_3d_obj(np.array(image), depth_image, image_path)\n", "        img = Image.fromarray(depth_image)\n", "        return [img, gltf_path, gltf_path]\n", "    except Exception:\n", "        gltf_path = create_3d_obj(\n", "            np.array(image), depth_image, image_path, depth=8)\n", "        img = Image.fromarray(depth_image)\n", "        return [img, gltf_path, gltf_path]\n", "    except:\n", "        print(\"Error reconstructing 3D model\")\n", "        raise Exception(\"Error reconstructing 3D model\")\n", "\n", "\n", "def create_3d_obj(rgb_image, depth_image, image_path, depth=10):\n", "    depth_o3d = o3d.geometry.Image(depth_image)\n", "    image_o3d = o3d.geometry.Image(rgb_image)\n", "    rgbd_image = o3d.geometry.RGBDImage.create_from_color_and_depth(\n", "        image_o3d, depth_o3d, convert_rgb_to_intensity=False)\n", "    w = int(depth_image.shape[1])\n", "    h = int(depth_image.shape[0])\n", "\n", "    camera_intrinsic = o3d.camera.PinholeCameraIntrinsic()\n", "    camera_intrinsic.set_intrinsics(w, h, 500, 500, w/2, h/2)\n", "\n", "    pcd = o3d.geometry.PointCloud.create_from_rgbd_image(\n", "        rgbd_image, camera_intrinsic)\n", "\n", "    print('normals')\n", "    pcd.normals = o3d.utility.Vector3dVector(\n", "        np.zeros((1, 3)))  # invalidate existing normals\n", "    pcd.estimate_normals(\n", "        search_param=o3d.geometry.KDTreeSearchParamHybrid(radius=0.01, max_nn=30))\n", "    pcd.orient_normals_towards_camera_location(\n", "        camera_location=np.array([0., 0., 1000.]))\n", "    pcd.transform([[1, 0, 0, 0],\n", "                   [0, -1, 0, 0],\n", "                   [0, 0, -1, 0],\n", "                   [0, 0, 0, 1]])\n", "    pcd.transform([[-1, 0, 0, 0],\n", "                   [0, 1, 0, 0],\n", "                   [0, 0, 1, 0],\n", "                   [0, 0, 0, 1]])\n", "\n", "    print('run Poisson surface reconstruction')\n", "    with o3d.utility.VerbosityContextManager(o3d.utility.VerbosityLevel.Debug):\n", "        mesh_raw, densities = o3d.geometry.TriangleMesh.create_from_point_cloud_poisson(\n", "            pcd, depth=depth, width=0, scale=1.1, linear_fit=True)\n", "\n", "    voxel_size = max(mesh_raw.get_max_bound() - mesh_raw.get_min_bound()) / 256\n", "    print(f'voxel_size = {voxel_size:e}')\n", "    mesh = mesh_raw.simplify_vertex_clustering(\n", "        voxel_size=voxel_size,\n", "        contraction=o3d.geometry.SimplificationContraction.Average)\n", "\n", "    # vertices_to_remove = densities < np.quantile(densities, 0.001)\n", "    # mesh.remove_vertices_by_mask(vertices_to_remove)\n", "    bbox = pcd.get_axis_aligned_bounding_box()\n", "    mesh_crop = mesh.crop(bbox)\n", "    gltf_path = f'./{image_path.stem}.gltf'\n", "    o3d.io.write_triangle_mesh(\n", "        gltf_path, mesh_crop, write_triangle_uvs=True)\n", "    return gltf_path\n", "\n", "title = \"Demo: zero-shot depth estimation with DPT + 3D Point Cloud\"\n", "description = \"This demo is a variation from the original <a href='https://huggingface.co/spaces/nielsr/dpt-depth-estimation' target='_blank'>DPT Demo</a>. It uses the DPT model to predict the depth of an image and then uses 3D Point Cloud to create a 3D object.\"\n", "examples = [[\"examples/1-jonathan-borba-CgWTqYxHEkg-unsplash.jpg\"]]\n", "\n", "iface = gr.Interface(fn=process_image,\n", "                     inputs=[gr.Image(\n", "                         type=\"filepath\", label=\"Input Image\")],\n", "                     outputs=[gr.Image(label=\"predicted depth\", type=\"pil\"),\n", "                              gr.Model3D(label=\"3d mesh reconstruction\", clear_color=[\n", "                                                 1.0, 1.0, 1.0, 1.0]),\n", "                              gr.File(label=\"3d gLTF\")],\n", "                     title=title,\n", "                     description=description,\n", "                     examples=examples,\n", "                     allow_flagging=\"never\",\n", "                     cache_examples=False)\n", "\n", "iface.launch(debug=True, enable_queue=False)"]}], "metadata": {}, "nbformat": 4, "nbformat_minor": 5}

groundingLMM/gradio-dev/demo/depth_estimation/run.py

@@ -0,0 +1,117 @@
+import gradio as gr
+from transformers import DPTFeatureExtractor, DPTForDepthEstimation
+import torch
+import numpy as np
+from PIL import Image
+import open3d as o3d
+from pathlib import Path
+
+feature_extractor = DPTFeatureExtractor.from_pretrained("Intel/dpt-large")
+model = DPTForDepthEstimation.from_pretrained("Intel/dpt-large")
+
+def process_image(image_path):
+    image_path = Path(image_path)
+    image_raw = Image.open(image_path)
+    image = image_raw.resize(
+        (800, int(800 * image_raw.size[1] / image_raw.size[0])),
+        Image.Resampling.LANCZOS)
+
+    # prepare image for the model
+    encoding = feature_extractor(image, return_tensors="pt")
+
+    # forward pass
+    with torch.no_grad():
+        outputs = model(**encoding)
+        predicted_depth = outputs.predicted_depth
+
+    # interpolate to original size
+    prediction = torch.nn.functional.interpolate(
+        predicted_depth.unsqueeze(1),
+        size=image.size[::-1],
+        mode="bicubic",
+        align_corners=False,
+    ).squeeze()
+    output = prediction.cpu().numpy()
+    depth_image = (output * 255 / np.max(output)).astype('uint8')
+    try:
+        gltf_path = create_3d_obj(np.array(image), depth_image, image_path)
+        img = Image.fromarray(depth_image)
+        return [img, gltf_path, gltf_path]
+    except Exception:
+        gltf_path = create_3d_obj(
+            np.array(image), depth_image, image_path, depth=8)
+        img = Image.fromarray(depth_image)
+        return [img, gltf_path, gltf_path]
+    except:
+        print("Error reconstructing 3D model")
+        raise Exception("Error reconstructing 3D model")
+
+
+def create_3d_obj(rgb_image, depth_image, image_path, depth=10):
+    depth_o3d = o3d.geometry.Image(depth_image)
+    image_o3d = o3d.geometry.Image(rgb_image)
+    rgbd_image = o3d.geometry.RGBDImage.create_from_color_and_depth(
+        image_o3d, depth_o3d, convert_rgb_to_intensity=False)
+    w = int(depth_image.shape[1])
+    h = int(depth_image.shape[0])
+
+    camera_intrinsic = o3d.camera.PinholeCameraIntrinsic()
+    camera_intrinsic.set_intrinsics(w, h, 500, 500, w/2, h/2)
+
+    pcd = o3d.geometry.PointCloud.create_from_rgbd_image(
+        rgbd_image, camera_intrinsic)
+
+    print('normals')
+    pcd.normals = o3d.utility.Vector3dVector(
+        np.zeros((1, 3)))  # invalidate existing normals
+    pcd.estimate_normals(
+        search_param=o3d.geometry.KDTreeSearchParamHybrid(radius=0.01, max_nn=30))
+    pcd.orient_normals_towards_camera_location(
+        camera_location=np.array([0., 0., 1000.]))
+    pcd.transform([[1, 0, 0, 0],
+                   [0, -1, 0, 0],
+                   [0, 0, -1, 0],
+                   [0, 0, 0, 1]])
+    pcd.transform([[-1, 0, 0, 0],
+                   [0, 1, 0, 0],
+                   [0, 0, 1, 0],
+                   [0, 0, 0, 1]])
+
+    print('run Poisson surface reconstruction')
+    with o3d.utility.VerbosityContextManager(o3d.utility.VerbosityLevel.Debug):
+        mesh_raw, densities = o3d.geometry.TriangleMesh.create_from_point_cloud_poisson(
+            pcd, depth=depth, width=0, scale=1.1, linear_fit=True)
+
+    voxel_size = max(mesh_raw.get_max_bound() - mesh_raw.get_min_bound()) / 256
+    print(f'voxel_size = {voxel_size:e}')
+    mesh = mesh_raw.simplify_vertex_clustering(
+        voxel_size=voxel_size,
+        contraction=o3d.geometry.SimplificationContraction.Average)
+
+    # vertices_to_remove = densities < np.quantile(densities, 0.001)
+    # mesh.remove_vertices_by_mask(vertices_to_remove)
+    bbox = pcd.get_axis_aligned_bounding_box()
+    mesh_crop = mesh.crop(bbox)
+    gltf_path = f'./{image_path.stem}.gltf'
+    o3d.io.write_triangle_mesh(
+        gltf_path, mesh_crop, write_triangle_uvs=True)
+    return gltf_path
+
+title = "Demo: zero-shot depth estimation with DPT + 3D Point Cloud"
+description = "This demo is a variation from the original <a href='https://huggingface.co/spaces/nielsr/dpt-depth-estimation' target='_blank'>DPT Demo</a>. It uses the DPT model to predict the depth of an image and then uses 3D Point Cloud to create a 3D object."
+examples = [["examples/1-jonathan-borba-CgWTqYxHEkg-unsplash.jpg"]]
+
+iface = gr.Interface(fn=process_image,
+                     inputs=[gr.Image(
+                         type="filepath", label="Input Image")],
+                     outputs=[gr.Image(label="predicted depth", type="pil"),
+                              gr.Model3D(label="3d mesh reconstruction", clear_color=[
+                                                 1.0, 1.0, 1.0, 1.0]),
+                              gr.File(label="3d gLTF")],
+                     title=title,
+                     description=description,
+                     examples=examples,
+                     allow_flagging="never",
+                     cache_examples=False)
+
+iface.launch(debug=True, enable_queue=False)

groundingLMM/gradio-dev/demo/diffusers_with_batching/requirements.txt

@@ -0,0 +1,3 @@
+torch
+transformers
+diffusers

groundingLMM/gradio-dev/demo/diffusers_with_batching/run.ipynb

@@ -0,0 +1 @@
+{"cells": [{"cell_type": "markdown", "id": 302934307671667531413257853548643485645, "metadata": {}, "source": ["# Gradio Demo: diffusers_with_batching"]}, {"cell_type": "code", "execution_count": null, "id": 272996653310673477252411125948039410165, "metadata": {}, "outputs": [], "source": ["!pip install -q gradio torch transformers diffusers"]}, {"cell_type": "code", "execution_count": null, "id": 288918539441861185822528903084949547379, "metadata": {}, "outputs": [], "source": ["import torch\n", "from diffusers import DiffusionPipeline\n", "import gradio as gr\n", "\n", "generator = DiffusionPipeline.from_pretrained(\"CompVis/ldm-text2im-large-256\")\n", "# move to GPU if available\n", "if torch.cuda.is_available():\n", "    generator = generator.to(\"cuda\")\n", "\n", "def generate(prompts):\n", "  images = generator(list(prompts)).images\n", "  return [images]\n", "\n", "demo = gr.Interface(generate, \n", "             \"textbox\", \n", "             \"image\", \n", "             batch=True, \n", "             max_batch_size=4  # Set the batch size based on your CPU/GPU memory\n", ").queue()\n", "\n", "if __name__ == \"__main__\":\n", "    demo.launch()\n"]}], "metadata": {}, "nbformat": 4, "nbformat_minor": 5}

groundingLMM/gradio-dev/demo/diffusers_with_batching/run.py

@@ -0,0 +1,22 @@
+import torch
+from diffusers import DiffusionPipeline
+import gradio as gr
+
+generator = DiffusionPipeline.from_pretrained("CompVis/ldm-text2im-large-256")
+# move to GPU if available
+if torch.cuda.is_available():
+    generator = generator.to("cuda")
+
+def generate(prompts):
+  images = generator(list(prompts)).images
+  return [images]
+
+demo = gr.Interface(generate, 
+             "textbox", 
+             "image", 
+             batch=True, 
+             max_batch_size=4  # Set the batch size based on your CPU/GPU memory
+).queue()
+
+if __name__ == "__main__":
+    demo.launch()

groundingLMM/gradio-dev/demo/fake_diffusion/DESCRIPTION.md

@@ -0,0 +1 @@
+This demo uses a fake model to showcase iterative output. The Image output will update every time a generator is returned until the final image.

groundingLMM/gradio-dev/demo/fake_diffusion/requirements.txt

@@ -0,0 +1 @@
+numpy

groundingLMM/gradio-dev/demo/fake_diffusion/run.ipynb

@@ -0,0 +1 @@
+{"cells": [{"cell_type": "markdown", "id": 302934307671667531413257853548643485645, "metadata": {}, "source": ["# Gradio Demo: fake_diffusion\n", "### This demo uses a fake model to showcase iterative output. The Image output will update every time a generator is returned until the final image.\n", "        "]}, {"cell_type": "code", "execution_count": null, "id": 272996653310673477252411125948039410165, "metadata": {}, "outputs": [], "source": ["!pip install -q gradio numpy "]}, {"cell_type": "code", "execution_count": null, "id": 288918539441861185822528903084949547379, "metadata": {}, "outputs": [], "source": ["import gradio as gr\n", "import numpy as np\n", "import time\n", "\n", "# define core fn, which returns a generator {steps} times before returning the image\n", "def fake_diffusion(steps):\n", "    for _ in range(steps):\n", "        time.sleep(1)\n", "        image = np.random.random((600, 600, 3))\n", "        yield image\n", "    image = \"https://gradio-builds.s3.amazonaws.com/diffusion_image/cute_dog.jpg\"\n", "    yield image\n", "\n", "\n", "demo = gr.Interface(fake_diffusion, inputs=gr.Slider(1, 10, 3), outputs=\"image\")\n", "\n", "# define queue - required for generators\n", "demo.queue()\n", "\n", "demo.launch()\n"]}], "metadata": {}, "nbformat": 4, "nbformat_minor": 5}

groundingLMM/gradio-dev/demo/fake_diffusion/run.py

@@ -0,0 +1,20 @@
+import gradio as gr
+import numpy as np
+import time
+
+# define core fn, which returns a generator {steps} times before returning the image
+def fake_diffusion(steps):
+    for _ in range(steps):
+        time.sleep(1)
+        image = np.random.random((600, 600, 3))
+        yield image
+    image = "https://gradio-builds.s3.amazonaws.com/diffusion_image/cute_dog.jpg"
+    yield image
+
+
+demo = gr.Interface(fake_diffusion, inputs=gr.Slider(1, 10, 3), outputs="image")
+
+# define queue - required for generators
+demo.queue()
+
+demo.launch()

groundingLMM/gradio-dev/demo/gender_sentence_custom_interpretation/run.ipynb

@@ -0,0 +1 @@
+{"cells": [{"cell_type": "markdown", "id": 302934307671667531413257853548643485645, "metadata": {}, "source": ["# Gradio Demo: gender_sentence_custom_interpretation"]}, {"cell_type": "code", "execution_count": null, "id": 272996653310673477252411125948039410165, "metadata": {}, "outputs": [], "source": ["!pip install -q gradio "]}, {"cell_type": "code", "execution_count": null, "id": 288918539441861185822528903084949547379, "metadata": {}, "outputs": [], "source": ["import re\n", "\n", "import gradio as gr\n", "\n", "male_words, female_words = [\"he\", \"his\", \"him\"], [\"she\", \"hers\", \"her\"]\n", "\n", "\n", "def gender_of_sentence(sentence):\n", "    male_count = len([word for word in sentence.split() if word.lower() in male_words])\n", "    female_count = len(\n", "        [word for word in sentence.split() if word.lower() in female_words]\n", "    )\n", "    total = max(male_count + female_count, 1)\n", "    return {\"male\": male_count / total, \"female\": female_count / total}\n", "\n", "\n", "# Number of arguments to interpretation function must\n", "# match number of inputs to prediction function\n", "def interpret_gender(sentence):\n", "    result = gender_of_sentence(sentence)\n", "    is_male = result[\"male\"] > result[\"female\"]\n", "    interpretation = []\n", "    for word in re.split(\"( )\", sentence):\n", "        score = 0\n", "        token = word.lower()\n", "        if (is_male and token in male_words) or (not is_male and token in female_words):\n", "            score = 1\n", "        elif (is_male and token in female_words) or (\n", "            not is_male and token in male_words\n", "        ):\n", "            score = -1\n", "        interpretation.append((word, score))\n", "    # Output must be a list of lists containing the same number of elements as inputs\n", "    # Each element corresponds to the interpretation scores for the given input\n", "    return [interpretation]\n", "\n", "\n", "demo = gr.Interface(\n", "    fn=gender_of_sentence,\n", "    inputs=gr.Textbox(value=\"She went to his house to get her keys.\"),\n", "    outputs=\"label\",\n", "    interpretation=interpret_gender,\n", ")\n", "\n", "if __name__ == \"__main__\":\n", "    demo.launch()\n"]}], "metadata": {}, "nbformat": 4, "nbformat_minor": 5}

groundingLMM/gradio-dev/demo/gender_sentence_custom_interpretation/run.py

@@ -0,0 +1,46 @@
+import re
+
+import gradio as gr
+
+male_words, female_words = ["he", "his", "him"], ["she", "hers", "her"]
+
+
+def gender_of_sentence(sentence):
+    male_count = len([word for word in sentence.split() if word.lower() in male_words])
+    female_count = len(
+        [word for word in sentence.split() if word.lower() in female_words]
+    )
+    total = max(male_count + female_count, 1)
+    return {"male": male_count / total, "female": female_count / total}
+
+
+# Number of arguments to interpretation function must
+# match number of inputs to prediction function
+def interpret_gender(sentence):
+    result = gender_of_sentence(sentence)
+    is_male = result["male"] > result["female"]
+    interpretation = []
+    for word in re.split("( )", sentence):
+        score = 0
+        token = word.lower()
+        if (is_male and token in male_words) or (not is_male and token in female_words):
+            score = 1
+        elif (is_male and token in female_words) or (
+            not is_male and token in male_words
+        ):
+            score = -1
+        interpretation.append((word, score))
+    # Output must be a list of lists containing the same number of elements as inputs
+    # Each element corresponds to the interpretation scores for the given input
+    return [interpretation]
+
+
+demo = gr.Interface(
+    fn=gender_of_sentence,
+    inputs=gr.Textbox(value="She went to his house to get her keys."),
+    outputs="label",
+    interpretation=interpret_gender,
+)
+
+if __name__ == "__main__":
+    demo.launch()

groundingLMM/gradio-dev/demo/hello_world_3/run.ipynb

@@ -0,0 +1 @@
+{"cells": [{"cell_type": "markdown", "id": 302934307671667531413257853548643485645, "metadata": {}, "source": ["# Gradio Demo: hello_world_3"]}, {"cell_type": "code", "execution_count": null, "id": 272996653310673477252411125948039410165, "metadata": {}, "outputs": [], "source": ["!pip install -q gradio "]}, {"cell_type": "code", "execution_count": null, "id": 288918539441861185822528903084949547379, "metadata": {}, "outputs": [], "source": ["import gradio as gr\n", "\n", "def greet(name, is_morning, temperature):\n", "    salutation = \"Good morning\" if is_morning else \"Good evening\"\n", "    greeting = f\"{salutation} {name}. It is {temperature} degrees today\"\n", "    celsius = (temperature - 32) * 5 / 9\n", "    return greeting, round(celsius, 2)\n", "\n", "demo = gr.Interface(\n", "    fn=greet,\n", "    inputs=[\"text\", \"checkbox\", gr.Slider(0, 100)],\n", "    outputs=[\"text\", \"number\"],\n", ")\n", "if __name__ == \"__main__\":\n", "    demo.launch()\n"]}], "metadata": {}, "nbformat": 4, "nbformat_minor": 5}

groundingLMM/gradio-dev/demo/hello_world_3/run.py

@@ -0,0 +1,15 @@
+import gradio as gr
+
+def greet(name, is_morning, temperature):
+    salutation = "Good morning" if is_morning else "Good evening"
+    greeting = f"{salutation} {name}. It is {temperature} degrees today"
+    celsius = (temperature - 32) * 5 / 9
+    return greeting, round(celsius, 2)
+
+demo = gr.Interface(
+    fn=greet,
+    inputs=["text", "checkbox", gr.Slider(0, 100)],
+    outputs=["text", "number"],
+)
+if __name__ == "__main__":
+    demo.launch()

groundingLMM/gradio-dev/demo/highlightedtext_component/run.ipynb

@@ -0,0 +1 @@
+{"cells": [{"cell_type": "markdown", "id": 302934307671667531413257853548643485645, "metadata": {}, "source": ["# Gradio Demo: highlightedtext_component"]}, {"cell_type": "code", "execution_count": null, "id": 272996653310673477252411125948039410165, "metadata": {}, "outputs": [], "source": ["!pip install -q gradio "]}, {"cell_type": "code", "execution_count": null, "id": 288918539441861185822528903084949547379, "metadata": {}, "outputs": [], "source": ["import gradio as gr \n", "\n", "css = \"footer {display: none !important;} .gradio-container {min-height: 0px !important;}\"\n", "\n", "with gr.Blocks(css=css) as demo:\n", "    gr.HighlightedText(value=[(\"Text\",\"Label 1\"),(\"to be\",\"Label 2\"),(\"highlighted\",\"Label 3\")])\n", "\n", "demo.launch()"]}], "metadata": {}, "nbformat": 4, "nbformat_minor": 5}

groundingLMM/gradio-dev/demo/highlightedtext_component/run.py

@@ -0,0 +1,8 @@
+import gradio as gr 
+
+css = "footer {display: none !important;} .gradio-container {min-height: 0px !important;}"
+
+with gr.Blocks(css=css) as demo:
+    gr.HighlightedText(value=[("Text","Label 1"),("to be","Label 2"),("highlighted","Label 3")])
+
+demo.launch()

groundingLMM/gradio-dev/demo/image_classifier/requirements.txt

@@ -0,0 +1,2 @@
+numpy
+tensorflow

groundingLMM/gradio-dev/demo/image_classifier/run.ipynb

@@ -0,0 +1 @@
+{"cells": [{"cell_type": "markdown", "id": 302934307671667531413257853548643485645, "metadata": {}, "source": ["# Gradio Demo: image_classifier"]}, {"cell_type": "code", "execution_count": null, "id": 272996653310673477252411125948039410165, "metadata": {}, "outputs": [], "source": ["!pip install -q gradio numpy tensorflow"]}, {"cell_type": "code", "execution_count": null, "id": 288918539441861185822528903084949547379, "metadata": {}, "outputs": [], "source": ["# Downloading files from the demo repo\n", "import os\n", "os.mkdir('files')\n", "!wget -q -O files/imagenet_labels.json https://github.com/gradio-app/gradio/raw/main/demo/image_classifier/files/imagenet_labels.json\n", "os.mkdir('images')\n", "!wget -q -O images/cheetah1.jpg https://github.com/gradio-app/gradio/raw/main/demo/image_classifier/images/cheetah1.jpg\n", "!wget -q -O images/lion.jpg https://github.com/gradio-app/gradio/raw/main/demo/image_classifier/images/lion.jpg"]}, {"cell_type": "code", "execution_count": null, "id": 44380577570523278879349135829904343037, "metadata": {}, "outputs": [], "source": ["import os\n", "import requests\n", "import tensorflow as tf\n", "\n", "import gradio as gr\n", "\n", "inception_net = tf.keras.applications.MobileNetV2()  # load the model\n", "\n", "# Download human-readable labels for ImageNet.\n", "response = requests.get(\"https://git.io/JJkYN\")\n", "labels = response.text.split(\"\\n\")\n", "\n", "\n", "def classify_image(inp):\n", "    inp = inp.reshape((-1, 224, 224, 3))\n", "    inp = tf.keras.applications.mobilenet_v2.preprocess_input(inp)\n", "    prediction = inception_net.predict(inp).flatten()\n", "    return {labels[i]: float(prediction[i]) for i in range(1000)}\n", "\n", "\n", "image = gr.Image(shape=(224, 224))\n", "label = gr.Label(num_top_classes=3)\n", "\n", "demo = gr.Interface(\n", "    fn=classify_image,\n", "    inputs=image,\n", "    outputs=label,\n", "    examples=[\n", "        os.path.join(os.path.abspath(''), \"images/cheetah1.jpg\"),\n", "        os.path.join(os.path.abspath(''), \"images/lion.jpg\")\n", "        ]\n", "    )\n", "\n", "if __name__ == \"__main__\":\n", "    demo.launch()\n", "\n"]}], "metadata": {}, "nbformat": 4, "nbformat_minor": 5}

groundingLMM/gradio-dev/demo/image_classifier/run.py

@@ -0,0 +1,36 @@
+import os
+import requests
+import tensorflow as tf
+
+import gradio as gr
+
+inception_net = tf.keras.applications.MobileNetV2()  # load the model
+
+# Download human-readable labels for ImageNet.
+response = requests.get("https://git.io/JJkYN")
+labels = response.text.split("\n")
+
+
+def classify_image(inp):
+    inp = inp.reshape((-1, 224, 224, 3))
+    inp = tf.keras.applications.mobilenet_v2.preprocess_input(inp)
+    prediction = inception_net.predict(inp).flatten()
+    return {labels[i]: float(prediction[i]) for i in range(1000)}
+
+
+image = gr.Image(shape=(224, 224))
+label = gr.Label(num_top_classes=3)
+
+demo = gr.Interface(
+    fn=classify_image,
+    inputs=image,
+    outputs=label,
+    examples=[
+        os.path.join(os.path.dirname(__file__), "images/cheetah1.jpg"),
+        os.path.join(os.path.dirname(__file__), "images/lion.jpg")
+        ]
+    )
+
+if __name__ == "__main__":
+    demo.launch()
+

groundingLMM/gradio-dev/demo/image_mod/run.ipynb

@@ -0,0 +1 @@
+{"cells": [{"cell_type": "markdown", "id": 302934307671667531413257853548643485645, "metadata": {}, "source": ["# Gradio Demo: image_mod"]}, {"cell_type": "code", "execution_count": null, "id": 272996653310673477252411125948039410165, "metadata": {}, "outputs": [], "source": ["!pip install -q gradio "]}, {"cell_type": "code", "execution_count": null, "id": 288918539441861185822528903084949547379, "metadata": {}, "outputs": [], "source": ["# Downloading files from the demo repo\n", "import os\n", "os.mkdir('images')\n", "!wget -q -O images/cheetah1.jpg https://github.com/gradio-app/gradio/raw/main/demo/image_mod/images/cheetah1.jpg\n", "!wget -q -O images/lion.jpg https://github.com/gradio-app/gradio/raw/main/demo/image_mod/images/lion.jpg\n", "!wget -q -O images/logo.png https://github.com/gradio-app/gradio/raw/main/demo/image_mod/images/logo.png\n", "!wget -q -O images/tower.jpg https://github.com/gradio-app/gradio/raw/main/demo/image_mod/images/tower.jpg"]}, {"cell_type": "code", "execution_count": null, "id": 44380577570523278879349135829904343037, "metadata": {}, "outputs": [], "source": ["import gradio as gr\n", "import os\n", "\n", "\n", "def image_mod(image):\n", "    return image.rotate(45)\n", "\n", "\n", "demo = gr.Interface(\n", "    image_mod,\n", "    gr.Image(type=\"pil\"),\n", "    \"image\",\n", "    flagging_options=[\"blurry\", \"incorrect\", \"other\"],\n", "    examples=[\n", "        os.path.join(os.path.abspath(''), \"images/cheetah1.jpg\"),\n", "        os.path.join(os.path.abspath(''), \"images/lion.jpg\"),\n", "        os.path.join(os.path.abspath(''), \"images/logo.png\"),\n", "        os.path.join(os.path.abspath(''), \"images/tower.jpg\"),\n", "    ],\n", ")\n", "\n", "if __name__ == \"__main__\":\n", "    demo.launch()\n"]}], "metadata": {}, "nbformat": 4, "nbformat_minor": 5}

groundingLMM/gradio-dev/demo/image_mod/run.py

@@ -0,0 +1,23 @@
+import gradio as gr
+import os
+
+
+def image_mod(image):
+    return image.rotate(45)
+
+
+demo = gr.Interface(
+    image_mod,
+    gr.Image(type="pil"),
+    "image",
+    flagging_options=["blurry", "incorrect", "other"],
+    examples=[
+        os.path.join(os.path.dirname(__file__), "images/cheetah1.jpg"),
+        os.path.join(os.path.dirname(__file__), "images/lion.jpg"),
+        os.path.join(os.path.dirname(__file__), "images/logo.png"),
+        os.path.join(os.path.dirname(__file__), "images/tower.jpg"),
+    ],
+)
+
+if __name__ == "__main__":
+    demo.launch()

groundingLMM/gradio-dev/demo/interface_parallel_load/run.ipynb

@@ -0,0 +1 @@
+{"cells": [{"cell_type": "markdown", "id": 302934307671667531413257853548643485645, "metadata": {}, "source": ["# Gradio Demo: interface_parallel_load"]}, {"cell_type": "code", "execution_count": null, "id": 272996653310673477252411125948039410165, "metadata": {}, "outputs": [], "source": ["!pip install -q gradio "]}, {"cell_type": "code", "execution_count": null, "id": 288918539441861185822528903084949547379, "metadata": {}, "outputs": [], "source": ["import gradio as gr\n", "\n", "generator1 = gr.load(\"huggingface/gpt2\")\n", "generator2 = gr.load(\"huggingface/EleutherAI/gpt-neo-2.7B\")\n", "generator3 = gr.load(\"huggingface/EleutherAI/gpt-j-6B\")\n", "\n", "demo = gr.Parallel(generator1, generator2, generator3)\n", "\n", "if __name__ == \"__main__\":\n", "    demo.launch()"]}], "metadata": {}, "nbformat": 4, "nbformat_minor": 5}

groundingLMM/gradio-dev/demo/interface_parallel_load/run.py

@@ -0,0 +1,10 @@
+import gradio as gr
+
+generator1 = gr.load("huggingface/gpt2")
+generator2 = gr.load("huggingface/EleutherAI/gpt-neo-2.7B")
+generator3 = gr.load("huggingface/EleutherAI/gpt-j-6B")
+
+demo = gr.Parallel(generator1, generator2, generator3)
+
+if __name__ == "__main__":
+    demo.launch()