text stringlengths 0 2k | heading1 stringlengths 3 79 | source_page_url stringclasses 189
values | source_page_title stringclasses 189
values |
|---|---|---|---|
✕| ✓| ✕| ✕| ✕| ✕| ✕| ✕| ✓| ✕| ✕|
✕| ✕| ✕| ✕| ✕| ✕| ✕| ✓| ✕| ✕| ✓| ✕| ✕| ✕| ✕| ✕| ✕
[HighlightedText](highlightedtext)| ✕| ✕| ✕| ✕| ✕| ✕| ✕| ✕| ✕| ✕| ✕| ✕| ✕| ✕|
✕| ✕| ✕| ✕| ✕| ✕| ✕| ✕| ✕| ✕| ✕| ✕| ✓| ✕| ✕| ✓| ✕| ✕| ✕| ✕| ✕| ✕
[HTML](html)| ✓| ✓| ✕| ✓| ✓| ✓| ✓| ✓| ✓| ✕| ✓| ✓| ✓| ✓| ✓| ✓| ✓| ✓| ✓| ✓| ✓|
✓| ✓| ✓| ✓| ... | Events | https://gradio.app/docs/gradio/introduction | Gradio - Introduction Docs |
ScatterPlot](scatterplot)| ✕| ✕| ✕| ✕| ✕| ✕| ✕| ✕| ✕| ✕| ✕| ✕| ✕| ✕| ✓| ✕| ✕|
✕| ✕| ✕| ✕| ✕| ✕| ✕| ✕| ✕| ✓| ✕| ✕| ✓| ✕| ✕| ✕| ✕| ✕| ✕
[Navbar](navbar)| ✕| ✕| ✕| ✕| ✕| ✕| ✕| ✕| ✕| ✕| ✕| ✕| ✕| ✕| ✕| ✕| ✕| ✕| ✕| ✕|
✕| ✕| ✕| ✕| ✕| ✕| ✓| ✕| ✕| ✕| ✕| ✕| ✕| ✕| ✕| ✕
[Number](number)| ✕| ✕| ✕| ✕| ✕| ✕| ✕| ✕| ✕| ✕| ✕| ✕| ✕| ... | Events | https://gradio.app/docs/gradio/introduction | Gradio - Introduction Docs |
Creates a code editor for viewing code (as an output component), or for
entering and editing code (as an input component).
| Description | https://gradio.app/docs/gradio/code | Gradio - Code Docs |
**Using Code as an input component.**
How Code will pass its value to your function:
Type: `str | None`
Passes the code entered as a `str`.
Example Code
import gradio as gr
def predict(
value: str | None
):
process value from the Code componen... | Behavior | https://gradio.app/docs/gradio/code | Gradio - Code Docs |
Parameters ▼
value: str | Callable | None
default `= None`
Default value to show in the code editor. If a function is provided, the
function will be called each time the app loads to set the initial value of
this component.
language: Literal['python', 'c', 'cpp', 'markdown', 'latex', '... | Initialization | https://gradio.app/docs/gradio/code | Gradio - Code Docs |
s
component is assigned to.
interactive: bool | None
default `= None`
Whether user should be able to enter code or only view it.
show_label: bool | None
default `= None`
if True, will display label.
container: bool
default `= True`
If True, will place the component ... | Initialization | https://gradio.app/docs/gradio/code | Gradio - Code Docs |
key: int | str | tuple[int | str, ...] | None
default `= None`
in a gr.render, Components with the same key across re-renders are treated as
the same component, not a new component. Properties set in 'preserved_by_key'
are not reset across a re-render.
preserved_by_key: list[str] | str | None
default... | Initialization | https://gradio.app/docs/gradio/code | Gradio - Code Docs |
Shortcuts
gradio.Code
Interface String Shortcut `"code"`
Initialization Uses default values
| Shortcuts | https://gradio.app/docs/gradio/code | Gradio - Code Docs |
Description
Event listeners allow you to respond to user interactions with the UI
components you've defined in a Gradio Blocks app. When a user interacts with
an element, such as changing a slider value or uploading an image, a function
is called.
Supported Event Listeners
The Code component supports the following e... | Event Listeners | https://gradio.app/docs/gradio/code | Gradio - Code Docs |
`gradio-rs` is a Gradio Client in Rust built by
[@JacobLinCool](https://github.com/JacobLinCool). You can find the repo
[here](https://github.com/JacobLinCool/gradio-rs), and more in depth API
documentation [here](https://docs.rs/gradio/latest/gradio/).
| Introduction | https://gradio.app/docs/third-party-clients/rust-client | Third Party Clients - Rust Client Docs |
Here is an example of using BS-RoFormer model to separate vocals and
background music from an audio file.
use gradio::{PredictionInput, Client, ClientOptions};
[tokio::main]
async fn main() {
if std::env::args().len() < 2 {
println!("Please provide an audio file path as a... | Usage | https://gradio.app/docs/third-party-clients/rust-client | Third Party Clients - Rust Client Docs |
cargo install gradio
gr --help
Take [stabilityai/stable-
diffusion-3-medium](https://huggingface.co/spaces/stabilityai/stable-
diffusion-3-medium) HF Space as an example:
> gr list stabilityai/stable-diffusion-3-medium
API Spec for stabilityai/stable-diffusion-3-medium:
/infer
... | Command Line Interface | https://gradio.app/docs/third-party-clients/rust-client | Third Party Clients - Rust Client Docs |
Gradio applications support programmatic requests from many environments:
* The [Python Client](/docs/python-client): `gradio-client` allows you to make requests from Python environments.
* The [JavaScript Client](/docs/js-client): `@gradio/client` allows you to make requests in TypeScript from the browser or serv... | Gradio Clients | https://gradio.app/docs/third-party-clients/introduction | Third Party Clients - Introduction Docs |
We also encourage the development and use of third party clients built by
the community:
* [Rust Client](/docs/third-party-clients/rust-client): `gradio-rs` built by [@JacobLinCool](https://github.com/JacobLinCool) allows you to make requests in Rust.
* [Powershell Client](https://github.com/rrg92/powershai): `pow... | Community Clients | https://gradio.app/docs/third-party-clients/introduction | Third Party Clients - Introduction Docs |
Gradio themes are the easiest way to customize the look and feel of your app. You can choose from a variety of themes, or create your own. To do so, pass the `theme=` kwarg to the `launch()` method of the `Blocks` constructor. For example:
```python
with gr.Blocks() as demo:
... your code here
demo.launch(theme=gr... | Adding custom CSS to your demo | https://gradio.app/guides/custom-CSS-and-JS | Building With Blocks - Custom Css And Js Guide |
You can `elem_id` to add an HTML element `id` to any component, and `elem_classes` to add a class or list of classes. This will allow you to select elements more easily with CSS. This approach is also more likely to be stable across Gradio versions as built-in class names or ids may change (however, as mentioned in the... | The `elem_id` and `elem_classes` Arguments | https://gradio.app/guides/custom-CSS-and-JS | Building With Blocks - Custom Css And Js Guide |
There are 3 ways to add javascript code to your Gradio demo:
1. You can add JavaScript code as a string to the `js` parameter of the `Blocks` or `Interface` initializer. This will run the JavaScript code when the demo is first loaded.
Below is an example of adding custom js to show an animated welcome message when th... | Adding custom JavaScript to your demo | https://gradio.app/guides/custom-CSS-and-JS | Building With Blocks - Custom Css And Js Guide |
n open-source web application showcasing various features and capabilities.">
<!-- Facebook Meta Tags -->
<meta property="og:url" content="https://example.com">
<meta property="og:type" content="website">
<meta property="og:title" content="Sample App">
<meta property="og:description" content="An open-source web applic... | Adding custom JavaScript to your demo | https://gradio.app/guides/custom-CSS-and-JS | Building With Blocks - Custom Css And Js Guide |
"input":
case "textarea":
break;
default:
if (e.key.toLowerCase() == "s" && e.shiftKey) {
document.getElementById("my_btn").click();
}
}
}
document.addEventListener('keypress', shortcuts, false);
</script>
"""
with gr.Blocks() as demo:
action_button = gr.Butt... | Adding custom JavaScript to your demo | https://gradio.app/guides/custom-CSS-and-JS | Building With Blocks - Custom Css And Js Guide |
In the example below, we will create a variable number of Textboxes. When the user edits the input Textbox, we create a Textbox for each letter in the input. Try it out below:
$code_render_split_simple
$demo_render_split_simple
See how we can now create a variable number of Textboxes using our custom logic - in this ... | Dynamic Number of Components | https://gradio.app/guides/dynamic-apps-with-render-decorator | Building With Blocks - Dynamic Apps With Render Decorator Guide |
If you're creating components, you probably want to attach event listeners to them as well. Let's take a look at an example that takes in a variable number of Textbox as input, and merges all the text into a single box.
$code_render_merge_simple
$demo_render_merge_simple
Let's take a look at what's happening here:
1... | Dynamic Event Listeners | https://gradio.app/guides/dynamic-apps-with-render-decorator | Building With Blocks - Dynamic Apps With Render Decorator Guide |
The `key=` argument tells Gradio that a component being created in a render function corresponds to the same logical component as in the previous render.
This allows Gradio to reuse the existing browser element instead of destroying and recreating it on every render. It also preserves the user's entered value across r... | Closer Look at `keys=` parameter | https://gradio.app/guides/dynamic-apps-with-render-decorator | Building With Blocks - Dynamic Apps With Render Decorator Guide |
Let's look at two examples that use all the features above. First, try out the to-do list app below:
$code_todo_list
$demo_todo_list
Note that almost the entire app is inside a single `gr.render` that reacts to the tasks `gr.State` variable. This variable is a nested list, which presents some complexity. If you desi... | Putting it Together | https://gradio.app/guides/dynamic-apps-with-render-decorator | Building With Blocks - Dynamic Apps With Render Decorator Guide |
The `gr.HTML` component can also be used to create custom input components by triggering events. You will provide `js_on_load`, javascript code that runs when the component loads. The code has access to the `trigger` function to trigger events that Gradio can listen to, and the object `props` which has access to all th... | Triggering Events and Custom Input Components | https://gradio.app/guides/custom-HTML-components | Building With Blocks - Custom Html Components Guide |
ce when the component is first rendered. If your component creates new elements dynamically that need event listeners, attach the event listener to a parent element that exists when the component loads, and check for the target. For example:
```js
element.addEventListener('click', (e) =>
if (e.target && e.target.m... | Triggering Events and Custom Input Components | https://gradio.app/guides/custom-HTML-components | Building With Blocks - Custom Html Components Guide |
The `watch` function, available inside `js_on_load`, lets you run a callback whenever specific props change when the component is an output to a Python event listener. Read current values directly from `props` inside the callback.
```js
// Watch a single prop
watch('value', () => {
console.log('value is now:', pro... | Watching Props with `watch` | https://gradio.app/guides/custom-HTML-components | Building With Blocks - Custom Html Components Guide |
The `head` parameter lets you load external JavaScript or CSS libraries directly on the component. The `head` content is injected and loaded **before** `js_on_load` runs, so your code can immediately use the library.
```python
gr.HTML(
value=[30, 70, 45, 90, 60],
html_template="<canvas id='chart'></canvas>",
... | Loading Third-Party Scripts with `head` | https://gradio.app/guides/custom-HTML-components | Building With Blocks - Custom Html Components Guide |
You can call Python functions directly from your `js_on_load` code using the `server_functions` parameter. Pass a list of Python functions to `server_functions`, and they become available as async methods on a `server` object inside `js_on_load`.
$code_html_server_functions
$demo_html_server_functions
| Server Functions | https://gradio.app/guides/custom-HTML-components | Building With Blocks - Custom Html Components Guide |
If you are reusing the same HTML component in multiple places, you can create a custom component class by subclassing `gr.HTML` and setting default values for the templates and other arguments. Here's an example of creating a reusable StarRating component.
$code_star_rating_component
$demo_star_rating_component
Note:... | Component Classes | https://gradio.app/guides/custom-HTML-components | Building With Blocks - Custom Html Components Guide |
The `gr.HTML` component can also be used as a container for other Gradio components using the `@children` placeholder. This allows you to create custom layouts with HTML/CSS.
The `@children` must be at the top-level of the `html_template`. Since children cannot be nested inside the template, target the parent element... | Embedding Components in HTML | https://gradio.app/guides/custom-HTML-components | Building With Blocks - Custom Html Components Guide |
Once you've built a custom HTML component, you can share it with the community by pushing it to the [HTML Components Gallery](https://www.gradio.app/custom-components/html-gallery). The gallery lets anyone browse, interact with, and copy the Python code for community-contributed components.
Call `push_to_hub` on any `... | Sharing Components with `push_to_hub` | https://gradio.app/guides/custom-HTML-components | Building With Blocks - Custom Html Components Guide |
Keep in mind that using `gr.HTML` to create custom components involves injecting raw HTML and JavaScript into your Gradio app. Be cautious about using untrusted user input into `html_template` and `js_on_load`, as this could lead to cross-site scripting (XSS) vulnerabilities.
You should also expect that any Python ev... | Security Considerations | https://gradio.app/guides/custom-HTML-components | Building With Blocks - Custom Html Components Guide |
- Browse the [HTML Components Gallery](https://www.gradio.app/custom-components/html-gallery) to see what the community has built and copy components into your own apps.
- Check out more examples in [this directory](https://github.com/gradio-app/gradio/tree/main/gradio/components/custom_html_components).
- Share your o... | Next Steps | https://gradio.app/guides/custom-HTML-components | Building With Blocks - Custom Html Components Guide |
Take a look at the demo below.
$code_hello_blocks
$demo_hello_blocks
- First, note the `with gr.Blocks() as demo:` clause. The Blocks app code will be contained within this clause.
- Next come the Components. These are the same Components used in `Interface`. However, instead of being passed to some constructor, Comp... | Blocks Structure | https://gradio.app/guides/blocks-and-event-listeners | Building With Blocks - Blocks And Event Listeners Guide |
In the example above, you'll notice that you are able to edit Textbox `name`, but not Textbox `output`. This is because any Component that acts as an input to an event listener is made interactive. However, since Textbox `output` acts only as an output, Gradio determines that it should not be made interactive. You can ... | Event Listeners and Interactivity | https://gradio.app/guides/blocks-and-event-listeners | Building With Blocks - Blocks And Event Listeners Guide |
Take a look at the demo below:
$code_blocks_hello
$demo_blocks_hello
Instead of being triggered by a click, the `welcome` function is triggered by typing in the Textbox `inp`. This is due to the `change()` event listener. Different Components support different event listeners. For example, the `Video` Component suppo... | Types of Event Listeners | https://gradio.app/guides/blocks-and-event-listeners | Building With Blocks - Blocks And Event Listeners Guide |
A Blocks app is not limited to a single data flow the way Interfaces are. Take a look at the demo below:
$code_reversible_flow
$demo_reversible_flow
Note that `num1` can act as input to `num2`, and also vice-versa! As your apps get more complex, you will have many data flows connecting various Components.
Here's an ... | Multiple Data Flows | https://gradio.app/guides/blocks-and-event-listeners | Building With Blocks - Blocks And Event Listeners Guide |
The event listeners you've seen so far have a single input component. If you'd like to have multiple input components pass data to the function, you have two options on how the function can accept input component values:
1. as a list of arguments, or
2. as a single dictionary of values, keyed by the component
Let's s... | Function Input List vs Set | https://gradio.app/guides/blocks-and-event-listeners | Building With Blocks - Blocks And Event Listeners Guide |
Similarly, you may return values for multiple output components either as:
1. a list of values, or
2. a dictionary keyed by the component
Let's first see an example of (1), where we set the values of two output components by returning two values:
```python
with gr.Blocks() as demo:
food_box = gr.Number(value=10,... | Function Return List vs Dict | https://gradio.app/guides/blocks-and-event-listeners | Building With Blocks - Blocks And Event Listeners Guide |
d_box` component.
Dictionary returns are helpful when an event listener affects many components on return, or conditionally affects outputs and not others.
Keep in mind that with dictionary returns, we still need to specify the possible outputs in the event listener.
| Function Return List vs Dict | https://gradio.app/guides/blocks-and-event-listeners | Building With Blocks - Blocks And Event Listeners Guide |
The return value of an event listener function is usually the updated value of the corresponding output Component. Sometimes we want to update the configuration of the Component as well, such as the visibility. In this case, we return a new Component, setting the properties we want to change.
$code_blocks_essay_simple... | Updating Component Configurations | https://gradio.app/guides/blocks-and-event-listeners | Building With Blocks - Blocks And Event Listeners Guide |
In some cases, you may want to leave a component's value unchanged. Gradio includes a special function, `gr.skip()`, which can be returned from your function. Returning this function will keep the output component (or components') values as is. Let us illustrate with an example:
$code_skip
$demo_skip
Note the differe... | Not Changing a Component's Value | https://gradio.app/guides/blocks-and-event-listeners | Building With Blocks - Blocks And Event Listeners Guide |
You can also run events consecutively by using the `then` method of an event listener. This will run an event after the previous event has finished running. This is useful for running events that update components in multiple steps.
For example, in the chatbot example below, we first update the chatbot with the user m... | Running Events Consecutively | https://gradio.app/guides/blocks-and-event-listeners | Building With Blocks - Blocks And Event Listeners Guide |
Often times, you may want to bind multiple triggers to the same function. For example, you may want to allow a user to click a submit button, or press enter to submit a form. You can do this using the `gr.on` method and passing a list of triggers to the `trigger`.
$code_on_listener_basic
$demo_on_listener_basic
You c... | Binding Multiple Triggers to a Function | https://gradio.app/guides/blocks-and-event-listeners | Building With Blocks - Blocks And Event Listeners Guide |
If you want to set a Component's value to always be a function of the value of other Components, you can use the following shorthand:
```python
with gr.Blocks() as demo:
num1 = gr.Number()
num2 = gr.Number()
product = gr.Number(lambda a, b: a * b, inputs=[num1, num2])
```
This functionally the same as:
```pytho... | Binding a Component Value Directly to a Function of Other Components | https://gradio.app/guides/blocks-and-event-listeners | Building With Blocks - Blocks And Event Listeners Guide |
Global state in Gradio apps is very simple: any variable created outside of a function is shared globally between all users.
This makes managing global state very simple and without the need for external services. For example, in this application, the `visitor_count` variable is shared between all users
```py
import ... | Global State | https://gradio.app/guides/state-in-blocks | Building With Blocks - State In Blocks Guide |
Gradio supports session state, where data persists across multiple submits within a page session. To reiterate, session data is _not_ shared between different users of your model, and does _not_ persist if a user refreshes the page to reload the Gradio app. To store data in a session state, you need to do three things:... | Session State | https://gradio.app/guides/state-in-blocks | Building With Blocks - State In Blocks Guide |
riggered if the **hash** of the value changes. So if you define a custom class and create a `gr.State` variable that is an instance of that class, make sure that the the class includes a sensible `__hash__` implementation.
The value of a session State variable is cleared when the user refreshes the page. The value is... | Session State | https://gradio.app/guides/state-in-blocks | Building With Blocks - State In Blocks Guide |
return "Error: Session not initialized"
with gr.Blocks() as demo:
output = gr.Textbox(label="Status")
counter = gr.Number(label="Counter Value")
increment_btn = gr.Button("Increment Counter")
increment_btn.click(increment_counter, inputs=None, outputs=counter)
Initialize instance when page ... | Session State | https://gradio.app/guides/state-in-blocks | Building With Blocks - State In Blocks Guide |
Gradio also supports browser state, where data persists in the browser's localStorage even after the page is refreshed or closed. This is useful for storing user preferences, settings, API keys, or other data that should persist across sessions. To use local state:
1. Create a `gr.BrowserState` object. You can optiona... | Browser State | https://gradio.app/guides/state-in-blocks | Building With Blocks - State In Blocks Guide |
Elements within a `with gr.Row` clause will all be displayed horizontally. For example, to display two Buttons side by side:
```python
with gr.Blocks() as demo:
with gr.Row():
btn1 = gr.Button("Button 1")
btn2 = gr.Button("Button 2")
```
You can set every element in a Row to have the same height. ... | Rows | https://gradio.app/guides/controlling-layout | Building With Blocks - Controlling Layout Guide |
Components within a Column will be placed vertically atop each other. Since the vertical layout is the default layout for Blocks apps anyway, to be useful, Columns are usually nested within Rows. For example:
$code_rows_and_columns
$demo_rows_and_columns
See how the first column has two Textboxes arranged vertically.... | Columns and Nesting | https://gradio.app/guides/controlling-layout | Building With Blocks - Controlling Layout Guide |
Some components support setting height and width. These parameters accept either a number (interpreted as pixels) or a string. Using a string allows the direct application of any CSS unit to the encapsulating Block element.
Below is an example illustrating the use of viewport width (vw):
```python
import gradio as gr... | Dimensions | https://gradio.app/guides/controlling-layout | Building With Blocks - Controlling Layout Guide |
You can also create Tabs using the `with gr.Tab('tab_name'):` clause. Any component created inside of a `with gr.Tab('tab_name'):` context appears in that tab. Consecutive Tab clauses are grouped together so that a single tab can be selected at one time, and only the components within that Tab's context are shown.
For... | Tabs and Accordions | https://gradio.app/guides/controlling-layout | Building With Blocks - Controlling Layout Guide |
The sidebar is a collapsible panel that renders child components on the left side of the screen and can be expanded or collapsed.
For example:
$code_blocks_sidebar
Learn more about [Sidebar](https://gradio.app/docs/gradio/sidebar) in the docs.
| Sidebar | https://gradio.app/guides/controlling-layout | Building With Blocks - Controlling Layout Guide |
In order to provide a guided set of ordered steps, a controlled workflow, you can use the `Walkthrough` component with accompanying `Step` components.
The `Walkthrough` component has a visual style and user experience tailored for this usecase.
Authoring this component is very similar to `Tab`, except it is the app d... | Multi-step walkthroughs | https://gradio.app/guides/controlling-layout | Building With Blocks - Controlling Layout Guide |
Both Components and Layout elements have a `visible` argument that can set initially and also updated. Setting `gr.Column(visible=...)` on a Column can be used to show or hide a set of Components.
$code_blocks_form
$demo_blocks_form
| Visibility | https://gradio.app/guides/controlling-layout | Building With Blocks - Controlling Layout Guide |
In some cases, you might want to define components before you actually render them in your UI. For instance, you might want to show an examples section using `gr.Examples` above the corresponding `gr.Textbox` input. Since `gr.Examples` requires as a parameter the input component object, you will need to first define th... | Defining and Rendering Components Separately | https://gradio.app/guides/controlling-layout | Building With Blocks - Controlling Layout Guide |
Let’s start with a simple example of integrating a C++ program into a Gradio app. Suppose we have the following C++ program that adds two numbers:
```cpp
// add.cpp
include <iostream>
int main() {
double a, b;
std::cin >> a >> b;
std::cout << a + b << std::endl;
return 0;
}
```
This program reads two... | Using Gradio with C++ | https://gradio.app/guides/using-gradio-in-other-programming-languages | Other Tutorials - Using Gradio In Other Programming Languages Guide |
Now, let’s move to another example: calling a Rust program to apply a sepia filter to an image. The Rust code could look something like this:
```rust
// sepia.rs
extern crate image;
use image::{GenericImageView, ImageBuffer, Rgba};
fn sepia_filter(input: &str, output: &str) {
let img = image::open(input).unwrap(... | Using Gradio with Rust | https://gradio.app/guides/using-gradio-in-other-programming-languages | Other Tutorials - Using Gradio In Other Programming Languages Guide |
nput Image"),
outputs=gr.Image(label="Sepia Image")
)
demo.launch()
```
Here, when a user uploads an image and clicks submit, Gradio calls the Rust binary (`sepia`) to process the image, and returns the sepia-filtered output to Gradio.
This setup showcases how you can integrate performance-critical or specializ... | Using Gradio with Rust | https://gradio.app/guides/using-gradio-in-other-programming-languages | Other Tutorials - Using Gradio In Other Programming Languages Guide |
Integrating Gradio with R is particularly straightforward thanks to the `reticulate` package, which allows you to run Python code directly in R. Let’s walk through an example of using Gradio in R.
**Installation**
First, you need to install the `reticulate` package in R:
```r
install.packages("reticulate")
```
On... | Using Gradio with R (via `reticulate`) | https://gradio.app/guides/using-gradio-in-other-programming-languages | Other Tutorials - Using Gradio In Other Programming Languages Guide |
A virtual environment in Python is a self-contained directory that holds a Python installation for a particular version of Python, along with a number of additional packages. This environment is isolated from the main Python installation and other virtual environments. Each environment can have its own independent set ... | Virtual Environments | https://gradio.app/guides/installing-gradio-in-a-virtual-environment | Other Tutorials - Installing Gradio In A Virtual Environment Guide |
To install Gradio on a Windows system in a virtual environment, follow these steps:
1. **Install Python**: Ensure you have Python 3.10 or higher installed. You can download it from [python.org](https://www.python.org/). You can verify the installation by running `python --version` or `python3 --version` in Command Pro... | Installing Gradio on Windows | https://gradio.app/guides/installing-gradio-in-a-virtual-environment | Other Tutorials - Installing Gradio In A Virtual Environment Guide |
The installation steps on MacOS and Linux are similar to Windows but with some differences in commands.
1. **Install Python**:
Python usually comes pre-installed on MacOS and most Linux distributions. You can verify the installation by running `python --version` in the terminal (note that depending on how Python is... | Installing Gradio on MacOS/Linux | https://gradio.app/guides/installing-gradio-in-a-virtual-environment | Other Tutorials - Installing Gradio In A Virtual Environment Guide |
By default, every Gradio demo includes a built-in queuing system that scales to thousands of requests. When a user of your app submits a request (i.e. submits an input to your function), Gradio adds the request to the queue, and requests are processed in order, generally speaking (this is not exactly true, as discussed... | Overview of Gradio's Queueing System | https://gradio.app/guides/setting-up-a-demo-for-maximum-performance | Other Tutorials - Setting Up A Demo For Maximum Performance Guide |
-single-worker** model by default. This means that each worker thread is only assigned a single function from among all of the functions that could be part of your Gradio app. This ensures that you do not see, for example, out-of-memory errors, due to multiple workers calling a machine learning model at the same time. ... | Overview of Gradio's Queueing System | https://gradio.app/guides/setting-up-a-demo-for-maximum-performance | Other Tutorials - Setting Up A Demo For Maximum Performance Guide |
sts are processed in parallel, each request will consume memory to store the data and weights for processing. This means that you might get out-of-memory errors if you increase the `default_concurrency_limit` too high. You may also start to get diminishing returns if the `default_concurrency_limit` is too high because ... | Overview of Gradio's Queueing System | https://gradio.app/guides/setting-up-a-demo-for-maximum-performance | Other Tutorials - Setting Up A Demo For Maximum Performance Guide |
is [guide](https://fastapi.tiangolo.com/async/) is a good primer on the concept.
The `max_size` parameter in `queue()`
A more blunt way to reduce the wait times is simply to prevent too many people from joining the queue in the first place. You can set the maximum number of requests that the queue processes using th... | Overview of Gradio's Queueing System | https://gradio.app/guides/setting-up-a-demo-for-maximum-performance | Other Tutorials - Setting Up A Demo For Maximum Performance Guide |
e passed into `gr.Interface()` or to an event in Blocks such as `.click()`.
While setting a batch is conceptually similar to having workers process requests in parallel, it is often _faster_ than setting `default_concurrency_limit` for deep learning models. The downside is that you might need to adapt your function a ... | Overview of Gradio's Queueing System | https://gradio.app/guides/setting-up-a-demo-for-maximum-performance | Other Tutorials - Setting Up A Demo For Maximum Performance Guide |
If you have done everything above, and your demo is still not fast enough, you can upgrade the hardware that your model is running on. Changing the model from running on CPUs to running on GPUs will usually provide a 10x-50x increase in inference time for deep learning models.
It is particularly straightforward to upg... | Upgrading your Hardware (GPUs, TPUs, etc.) | https://gradio.app/guides/setting-up-a-demo-for-maximum-performance | Other Tutorials - Setting Up A Demo For Maximum Performance Guide |
Congratulations! You know how to set up a Gradio demo for maximum performance. Good luck on your next viral demo!
| Conclusion | https://gradio.app/guides/setting-up-a-demo-for-maximum-performance | Other Tutorials - Setting Up A Demo For Maximum Performance Guide |
Tabular data science is the most widely used domain of machine learning, with problems ranging from customer segmentation to churn prediction. Throughout various stages of the tabular data science workflow, communicating your work to stakeholders or clients can be cumbersome; which prevents data scientists from focusin... | Introduction | https://gradio.app/guides/using-gradio-for-tabular-workflows | Other Tutorials - Using Gradio For Tabular Workflows Guide |
We will take a look at how we can create a simple UI that predicts failures based on product information.
```python
import gradio as gr
import pandas as pd
import joblib
import datasets
inputs = [gr.Dataframe(row_count = (2, "dynamic"), col_count=(4,"dynamic"), label="Input Data", interactive=1)]
outputs = [gr.Data... | Let's Create a Simple Interface! | https://gradio.app/guides/using-gradio-for-tabular-workflows | Other Tutorials - Using Gradio For Tabular Workflows Guide |
app space="gradio/tabular-playground"></gradio-app>
```python
import gradio as gr
import pandas as pd
import datasets
import seaborn as sns
import matplotlib.pyplot as plt
df = datasets.load_dataset("merve/supersoaker-failures")
df = df["train"].to_pandas()
df.dropna(axis=0, inplace=True)
def plot(df):
plt.scatter... | Let's Create a Simple Interface! | https://gradio.app/guides/using-gradio-for-tabular-workflows | Other Tutorials - Using Gradio For Tabular Workflows Guide |
`skops` is a library built on top of `huggingface_hub` and `sklearn`. With the recent `gradio` integration of `skops`, you can build tabular data interfaces with one line of code!
```python
import gradio as gr
title and description are optional
title = "Supersoaker Defective Product Prediction"
description = "This mo... | Easily load tabular data interfaces with one line of code using skops | https://gradio.app/guides/using-gradio-for-tabular-workflows | Other Tutorials - Using Gradio For Tabular Workflows Guide |
In this guide we will demonstrate some of the ways you can use Gradio with Comet. We will cover the basics of using Comet with Gradio and show you some of the ways that you can leverage Gradio's advanced features such as [Embedding with iFrames](https://www.gradio.app/guides/sharing-your-app/embedding-with-iframes) and... | Introduction | https://gradio.app/guides/Gradio-and-Comet | Other Tutorials - Gradio And Comet Guide |
[Comet](https://www.comet.com?utm_source=gradio&utm_medium=referral&utm_campaign=gradio-integration&utm_content=gradio-docs) is an MLOps Platform that is designed to help Data Scientists and Teams build better models faster! Comet provides tooling to Track, Explain, Manage, and Monitor your models in a single place! It... | What is Comet? | https://gradio.app/guides/Gradio-and-Comet | Other Tutorials - Gradio And Comet Guide |
First, install the dependencies needed to run these examples
```shell
pip install comet_ml torch torchvision transformers gradio shap requests Pillow
```
Next, you will need to [sign up for a Comet Account](https://www.comet.com/signup?utm_source=gradio&utm_medium=referral&utm_campaign=gradio-integration&utm_content=... | Setup | https://gradio.app/guides/Gradio-and-Comet | Other Tutorials - Gradio And Comet Guide |
[](https://colab.research.google.com/github/comet-ml/comet-examples/blob/master/integrations/model-evaluation/gradio/notebooks/Gradio_and_Comet.ipynb)
In this example, we will go over how to log your Gradio Applications to Comet and interact wit... | 1. Logging Gradio UI's to your Comet Experiments | https://gradio.app/guides/Gradio-and-Comet | Other Tutorials - Gradio And Comet Guide |
r-images.githubusercontent.com/7529846/214328034-09369d4d-8b94-4c4a-aa3c-25e3ed8394c4.mp4"></source>
</video>
Add the Gradio Panel to your Experiment to interact with your application.
<video width="560" height="315" controls>
<source src="https://user-images.githubusercontent.com/7529846/214328194-95987f83-c180-... | 1. Logging Gradio UI's to your Comet Experiments | https://gradio.app/guides/Gradio-and-Comet | Other Tutorials - Gradio And Comet Guide |
<iframe width="560" height="315" src="https://www.youtube.com/embed/KZnpH7msPq0?start=9" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>
If you are permanently hosting your Gradio applicat... | 2. Embedding Gradio Applications directly into your Comet Projects | https://gradio.app/guides/Gradio-and-Comet | Other Tutorials - Gradio And Comet Guide |
<iframe width="560" height="315" src="https://www.youtube.com/embed/KZnpH7msPq0?start=107" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>
You can also embed Gradio Applications that are h... | 3. Embedding Hugging Face Spaces directly into your Comet Projects | https://gradio.app/guides/Gradio-and-Comet | Other Tutorials - Gradio And Comet Guide |
<iframe width="560" height="315" src="https://www.youtube.com/embed/KZnpH7msPq0?start=176" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>
[![Open In Colab](https://colab.research.google.c... | 4. Logging Model Inferences to Comet | https://gradio.app/guides/Gradio-and-Comet | Other Tutorials - Gradio And Comet Guide |
"""Returns an APIExperiment object that is thread safe
and can be used to log inferences to a single Experiment
"""
try:
api = comet_ml.API()
workspace = api.get_default_workspace()
project_name = comet_ml.config.get_config()["comet.project_name"]
experiment = comet_ml.API... | 4. Logging Model Inferences to Comet | https://gradio.app/guides/Gradio-and-Comet | Other Tutorials - Gradio And Comet Guide |
887c-065aca14dd30.mp4"></source>
</video>
| 4. Logging Model Inferences to Comet | https://gradio.app/guides/Gradio-and-Comet | Other Tutorials - Gradio And Comet Guide |
We hope you found this guide useful and that it provides some inspiration to help you build awesome model evaluation workflows with Comet and Gradio.
| Conclusion | https://gradio.app/guides/Gradio-and-Comet | Other Tutorials - Gradio And Comet Guide |
- Create an account on Hugging Face [here](https://huggingface.co/join).
- Add Gradio Demo under your username, see this [course](https://huggingface.co/course/chapter9/4?fw=pt) for setting up Gradio Demo on Hugging Face.
- Request to join the Comet organization [here](https://huggingface.co/Comet).
| How to contribute Gradio demos on HF spaces on the Comet organization | https://gradio.app/guides/Gradio-and-Comet | Other Tutorials - Gradio And Comet Guide |
- [Comet Documentation](https://www.comet.com/docs/v2/?utm_source=gradio&utm_medium=referral&utm_campaign=gradio-integration&utm_content=gradio-docs)
| Additional Resources | https://gradio.app/guides/Gradio-and-Comet | Other Tutorials - Gradio And Comet Guide |
Make sure you have Gradio installed along with a recent version of `huggingface_hub`:
```bash
pip install --upgrade gradio huggingface_hub
```
> `huggingface_hub >= 1.4.0` is required for the skills command.
| Prerequisites | https://gradio.app/guides/Gradio-skills-for-ai-coding-assistants | Other Tutorials - Gradio Skills For Ai Coding Assistants Guide |
The general Gradio skill gives your assistant comprehensive knowledge of the Gradio API — components, event listeners, layout patterns, and working examples.
To install, pass the flag for your assistant:
```bash
gradio skills add --cursor or --claude, --codex, --opencode
```
This downloads two files (`SKILL.md` an... | Installing the General Gradio Skill | https://gradio.app/guides/Gradio-skills-for-ai-coding-assistants | Other Tutorials - Gradio Skills For Ai Coding Assistants Guide |
By default, skills are installed **locally** in your current project directory. This means the assistant only has Gradio knowledge when working in that project.
To install **globally** (user-level, available in all projects):
```bash
gradio skills add --claude --global
```
Or using the short flag:
```bash
gradio sk... | Project-Level vs. Global Installation | https://gradio.app/guides/Gradio-skills-for-ai-coding-assistants | Other Tutorials - Gradio Skills For Ai Coding Assistants Guide |
One of the most powerful features is generating a skill for any public HuggingFace Space. This gives your assistant full knowledge of that Space's API — endpoints, parameters, return types, and ready-to-use code snippets.
```bash
gradio skills add abidlabs/english-translator --claude
```
This connects to the Space, e... | Generating a Skill for a Specific HuggingFace Space | https://gradio.app/guides/Gradio-skills-for-ai-coding-assistants | Other Tutorials - Gradio Skills For Ai Coding Assistants Guide |
If a skill is already installed, the command will exit with an error. To overwrite it:
```bash
gradio skills add --claude --force
```
| Overwriting Existing Skills | https://gradio.app/guides/Gradio-skills-for-ai-coding-assistants | Other Tutorials - Gradio Skills For Ai Coding Assistants Guide |
General Gradio Skill
| File | Contents |
|------|----------|
| `SKILL.md` | Core API reference — component signatures, event listeners, layout patterns, ChatInterface, and links to detailed guides |
| `examples.md` | Complete working Gradio apps covering common patterns (forms, chatbots, streaming, image processing, e... | What Gets Installed | https://gradio.app/guides/Gradio-skills-for-ai-coding-assistants | Other Tutorials - Gradio Skills For Ai Coding Assistants Guide |
Here's a typical workflow using skills with Claude Code:
1. **Install the skill** in your project:
```bash
cd my-project
gradio skills add --claude
```
2. **Start Claude Code** and ask it to build a Gradio app:
```
> Build me a Gradio app with an image input that applies a sepia filter
and disp... | Example Workflow | https://gradio.app/guides/Gradio-skills-for-ai-coding-assistants | Other Tutorials - Gradio Skills For Ai Coding Assistants Guide |
Image classification is a central task in computer vision. Building better classifiers to classify what object is present in a picture is an active area of research, as it has applications stretching from autonomous vehicles to medical imaging.
Such models are perfect to use with Gradio's _image_ input component, so i... | Introduction | https://gradio.app/guides/image-classification-in-pytorch | Other Tutorials - Image Classification In Pytorch Guide |
First, we will need an image classification model. For this tutorial, we will use a pretrained Resnet-18 model, as it is easily downloadable from [PyTorch Hub](https://pytorch.org/hub/pytorch_vision_resnet/). You can use a different pretrained model or train your own.
```python
import torch
model = torch.hub.load('py... | Step 1 — Setting up the Image Classification Model | https://gradio.app/guides/image-classification-in-pytorch | Other Tutorials - Image Classification In Pytorch Guide |
Next, we will need to define a function that takes in the _user input_, which in this case is an image, and returns the prediction. The prediction should be returned as a dictionary whose keys are class name and values are confidence probabilities. We will load the class names from this [text file](https://git.io/JJkYN... | Step 2 — Defining a `predict` function | https://gradio.app/guides/image-classification-in-pytorch | Other Tutorials - Image Classification In Pytorch Guide |
Now that we have our predictive function set up, we can create a Gradio Interface around it.
In this case, the input component is a drag-and-drop image component. To create this input, we use `Image(type="pil")` which creates the component and handles the preprocessing to convert that to a `PIL` image.
The output com... | Step 3 — Creating a Gradio Interface | https://gradio.app/guides/image-classification-in-pytorch | Other Tutorials - Image Classification In Pytorch Guide |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.