Gradio: Einblick in die Integration von Modellen auf dem Hugging Face Hub
Einführung
Gradio hat sich als eine der bevorzugten Plattformen etabliert, die es ermöglicht, maschinelle Lernmodelle einfach und intuitiv zu präsentieren. In Zusammenarbeit mit Hugging Face bietet Gradio den Nutzern eine Vielzahl von Möglichkeiten, Modelle zu integrieren und zu testen. Diese Artikel beleuchtet die verschiedenen Aspekte und Funktionen von Gradio in Verbindung mit dem Hugging Face Hub, und stellt dar, wie Entwickler und Forscher diese Tools effektiv nutzen können.
Gradio und der Hugging Face Hub
Der Hugging Face Hub ist eine zentrale Plattform, die Hunderttausende von Modellen, Datensätzen und Demos (auch als Spaces bekannt) beherbergt. Gradio bietet mehrere Funktionen, die es extrem einfach machen, bestehende Modelle und Spaces auf dem Hub zu nutzen. Eins dieser Features ist die Möglichkeit, Demos mit den Inference Endpoints von Hugging Face zu erstellen.
Demos mit Hugging Face Inference Endpoints
Hugging Face bietet einen Dienst namens Serverless Inference Endpoints an, mit dem man HTTP-Anfragen an Modelle auf dem Hub senden kann. Dieses API beinhaltet einen großzügigen kostenlosen Tarif, und man kann zu dedizierten Inference Endpoints wechseln, wenn man es in der Produktion verwenden möchte.
Mit Gradio kann man eine Demo einfach erstellen, indem man den Namen des Modells angibt. Gradio übernimmt automatisch die erwarteten Eingaben und Ausgaben und führt die notwendigen Serveraufrufe durch, sodass man sich nicht um die Definition der Vorhersagefunktion kümmern muss.
```python
import gradio as gr
demo = gr.load("Helsinki-NLP/opus-mt-en-es", src="models")
demo.launch()
```
Beim ersten Inferenzdurchlauf kann es zu einer leichten Verzögerung kommen, da das Modell auf dem Server geladen wird. Danach profitieren die Nutzer von schnelleren Inferenzzeiten, Server-Caching und automatischer Skalierung.
Hosting von Gradio Demos auf Spaces
Hugging Face Spaces ermöglicht es jedem, seine Gradio Demos kostenlos zu hosten. Das Hochladen Ihrer Gradio Demos dauert nur wenige Minuten. Man kann entweder die GUI verwenden oder alles in Python programmatisch erstellen.
```python
from huggingface_hub import create_repo, get_full_repo_name, upload_file
create_repo(name=target_space_name, token=hf_token, repo_type="space", space_sdk="gradio")
repo_name = get_full_repo_name(model_id=target_space_name, token=hf_token)
file_url = upload_file(
path_or_fileobj="file.txt",
path_in_repo="app.py",
repo_id=repo_name,
repo_type="space",
token=hf_token,
)
```
Remixen von bestehenden Gradio Demos auf Hugging Face Spaces
Nutzer können bestehende Gradio Demos auf Hugging Face Spaces verwenden und remixen. Beispielsweise könnte man zwei bestehende Gradio Demos als separate Tabs zusammenführen und eine neue Demo erstellen.
```python
import gradio as gr
with gr.Blocks() as demo:
with gr.Tab("Translate to Spanish"):
gr.load("gradio/en2es", src="spaces")
with gr.Tab("Translate to French"):
gr.load("abidlabs/en2fr", src="spaces")
demo.launch()
```
Integration mit der Pipeline in transformers
Die transformers-Bibliothek von Hugging Face bietet eine einfache Abstraktion, pipeline(), die den Großteil des komplexen Codes handhabt, um eine einfache API für gängige Aufgaben bereitzustellen. Man kann eine Demo um ein bestehendes Modell herum mit wenigen Zeilen Python-Code erstellen.
```python
import gradio as gr
from transformers import pipeline
pipe = pipeline("translation", model="Helsinki-NLP/opus-mt-en-es")
def predict(text):
return pipe(text)[0]["translation_text"]
demo = gr.Interface(
fn=predict,
inputs='text',
outputs='text',
)
demo.launch()
```
Gradio macht es sogar noch einfacher, eine Pipeline in eine Demo zu konvertieren, indem man die Methode gradio.Interface.from_pipeline verwendet.
```python
from transformers import pipeline
import gradio as gr
pipe = pipeline("translation", model="Helsinki-NLP/opus-mt-en-es")
demo = gr.Interface.from_pipeline(pipe)
demo.launch()
```
Fazit
Gradio und Hugging Face bieten zusammen ein leistungsstarkes Ökosystem, das die Entwicklung und das Teilen von maschinellen Lernmodellen vereinfacht. Die nahtlose Integration von Gradio Demos mit Hugging Face Inference Endpoints und Spaces eröffnet Entwicklern und Forschern eine Vielzahl von Möglichkeiten. Diese Zusammenarbeit ermöglicht es, Modelle effizient zu testen, zu präsentieren und zu skalieren, ohne sich um die zugrunde liegende Infrastruktur kümmern zu müssen.
Bibliografie
- https://gradio.app/
- https://www.gradio.app/guides/using-hugging-face-integrations
- https://x.com/_akhaliq?lang=de
- https://github.com/gradio-app/gradio/issues/1481
- https://huggingface.co/akhaliq
- https://huggingface.co/docs/hub/spaces-sdks-gradio
- https://www.gradio.app/guides/Gradio-and-ONNX-on-Hugging-Face
