Gradio: die Nummer-eins-Schnittstelle für Machine Learning — eine Codezeile zwischen Modell und Welt

Gradio: die Nummer-eins-Schnittstelle für Machine Learning — eine Codezeile zwischen Modell und Welt

Die Machine-Learning-Community hat ein schmutziges Geheimnis: Sie ist brillant darin, Modelle zu bauen, und miserabel darin, sie Menschen zu zeigen. Sie trainieren einen Klassifikator, der eine EKG-Anomalie erkennt, oder einen fotorealistischen Generator, der eine Katze im Stil van Goghs malt — und dann? Das Modell liegt in einem Jupyter-Notebook. Ihr Kollege kann es nicht nutzen, weil er kein Python hat. Ihr Stakeholder will einen Link, keine Vorlesung. Ihr Modell ist exzellent und im Moment für die Welt völlig nutzlos.

Ein Machine-Learning-Modell ist nur so wertvoll wie die Schnittstelle, die es einem Menschen ermöglicht, es zu nutzen. Gradio ist diese Schnittstelle — und hat sich zur Nummer-eins-Methode entwickelt, mit der die Welt KI berührt. Eine Python-Funktion, eine Zeile, ein Browser-Tab. Das ist die ganze Magie.

Dieser Artikel ist der vollständige Rundgang durch Gradio, das Framework, das ML-Demos von einem schmerzhaften Ritual in eine Zwei-Minuten-Aufgabe verwandelt hat. Ich gehe auf die Entstehungsgeschichte ein, die drei APIs, die jeden Anwendungsfall abdecken (gr.Interface, gr.Blocks, gr.ChatInterface), den kompletten Komponenten-Zoo, Events und State, Sharing-Links und Hugging Face Spaces, Theming, Deployment und — mit voller Offenheit — wo es jede Alternative schlägt und wo nicht. Am Ende verstehen Sie, warum Gradio zur Standard-Schnittstellenschicht für Machine Learning geworden ist, und Sie können eine nutzbare ML-App in der Zeit ausliefern, die Sie zum Lesen dieses Abschnitts brauchen.

Die Entstehungsgeschichte: ein Dissertationsprojekt, das zum Standard wurde

Gradio entstand 2019 während der Doktorarbeit von Abubakar Abid an der Stanford University und wurde im Dezember 2021 von Hugging Face übernommen [3]. Was als Werkzeug begann, um die eigene Machine-Learning-Forschung zugänglich zu machen, entwickelte sich zu einem der meistgenutzten Tools für den Bau und die Verbreitung von ML-Demos [3]. Es steht unter einer liberalen Open-Source-Lizenz – ein entscheidender Grund für seine schnelle Verbreitung [3].

Der Zeitpunkt war vorausschauend. 2019 begann gerade die Transformer-Welle; bis Mitte der 2020er brauchte jedes ernsthafte ML-Projekt – Bildgenerierung, Sprachsynthese, LLMs – eine Möglichkeit, erlebbar zu sein, nicht nur bewertbar. Gradio stand genau dort, wo dieser Bedarf aufkam, und Hugging Face bot ihm ein dauerhaftes Zuhause im Zentrum des offenen KI-Ökosystems. Heute wird ein Modell, das auf dem Hugging Face Hub veröffentlicht wird, fast immer mit einer Gradio-Demo ausgeliefert [2].

Warum Interfaces der eigentliche Flaschenhals im Machine Learning sind

Jedes ML-Team stößt irgendwann auf dieselbe Mauer: Der schwierigste Teil bei der Bereitstellung eines Modells ist selten das Modell selbst. Es ist die letzte Meile – aus roher Inferenz etwas zu machen, das ein Mensch ansteuern und nutzen kann. Ohne Interface können Stakeholder die Arbeit nicht bewerten, Nutzer sie nicht adaptieren, und das Modell bleibt eine Zahl auf einer Bestenliste. Die „Demo-Lücke“ ist der Abstand zwischen „das Modell funktioniert“ und „die Organisation setzt es ein“ – und genau hier scheitern die meisten ML-Projekte leise.

Vor Gradio bedeutete die Überbrückung dieser Lücke, Webentwicklung zu lernen: React, Flask, WebSockets, Deployment-Pipelines und jede Menge CSS. Gradio hat den gesamten Stack auf eine einzige Python-Bibliothek reduziert. Sie beschreiben Ein- und Ausgaben — ein Bild rein, ein Label raus — und Gradio baut die Browser-UI, führt die Inferenz durch und rendert das Ergebnis. Kein JavaScript. Kein Frontend. Kein DevOps-Ritual.

Die drei APIs, die alles abdecken

Gradio ist nicht ein Tool, sondern drei, die so geschichtet sind, dass Sie auf der einfachsten Ebene beginnen und wachsen können, ohne neu zu schreiben:

• gr.Interface — der schnellste Weg von einer Python-Funktion zur Web-App. Eine Wrapper-Klasse, eine Zeile, fertig. Ideal für Demos, Evaluierungen und Tools mit einem einzigen Zweck.
• gr.Blocks — eine Layout-Engine für alles Komplexere. Erstellen Sie Apps mit mehreren Komponenten und Schritten, benutzerdefinierten Layouts, Tabs und Event-Verknüpfungen. Hier wird Gradio zu einem echten Anwendungsframework.
• gr.ChatInterface — eine spezialisierte Klasse für konversationelle Anwendungen. Geben Sie ihr eine Funktion, die eine Nachricht entgegennimmt und eine Antwort zurückgibt; Gradio liefert Ihnen ein ChatGPT-reifes Chat-Fenster mit Verlauf, Streaming und Wiederholungsfunktion kostenlos dazu [2].

Die Designphilosophie ist bewusst gewählt: Der 80-%-Fall (ein Modell rein, ein Ergebnis raus) soll eine Zeile kosten, und der 20-%-Fall (komplexe UIs mit mehreren Schritten) soll tatsächlich unterstützt werden — nicht nur angehängt. Deshalb treibt dieselbe Bibliothek sowohl einen 10-zeiligen Bildklassifizierer-Demo als auch produktive interne Tools mit Dutzenden Komponenten an.

gr.Interface: drei Zeilen bis zu Ihrer ersten ML-App

Installation ist ein Befehl, und die erste App besteht aus drei Codezeilen:

pip install gradio

import gradio as gr

def greet(name):
    return f"Hello, {name}!"

demo = gr.Interface(fn=greet, inputs="text", outputs="text")
demo.launch()

Führen Sie es aus, und ein Browser öffnet sich unter http://127.0.0.1:7860 mit einer funktionierenden Text-Eingabe/Text-Ausgabe-App. Die gr.Interface Klasse leitet den Komponententyp aus der String-Kurzschreibweise ab ("text", "image", "audio"); Sie können auch explizite Komponenteninstanzen übergeben, wenn Sie Parameter wie Labels und Standardwerte benötigen. Das ist die gesamte Einarbeitung — wenn Sie eine Python-Funktion schreiben können, liefern Sie in unter einer Minute eine ML-App aus.

Ein etwas realistischeres Beispiel — ein Bildklassifikator, der ein Bild entgegennimmt und eine Top-3-Vorhersage zurückgibt — ist kaum länger:

import gradio as gr

def classify(image):
    # model.predict(image) -> ["cat", "dog", "bird"]
    return top3(image)

demo = gr.Interface(
    fn=classify,
    inputs=gr.Image(type="pil"),
    outputs=gr.Label(num_top_classes=3),
    title="Animal Classifier",
    description="Upload a photo and see the top-3 predictions.",
)
demo.launch()

Beachten Sie, was Gradio für Sie erledigt hat: das Bild-Upload-Widget, die Dateidekodierung in ein PIL-Bild serverseitig, die Label-Ausgabe mit Konfidenzbalken, Titel und Beschreibung sowie den Start des Servers. Sie haben nie HTML, CSS oder JavaScript berührt [2].

Der Komponenten-Zoo: über 40 Wege, Daten hinein- und herauszubekommen

Gradio liefert über 40 Komponententypen aus, die für das gesamte Spektrum von ML-Daten konzipiert sind [2]. Das ist einer der Punkte, die es grundlegend von generischen Web-Frameworks unterscheiden — die Komponenten sind die Datentypen des Machine Learning:

• Text:gr.Textbox (ein- oder mehrzeilig), gr.Dropdown, gr.Radio, gr.CheckboxGroup, gr.Number, gr.Slider — alle Formular-Grundelemente, die Sie für Hyperparameter und Prompts brauchen.
• Bild:gr.Image (Hochladen, Webcam-Aufnahme oder Canvas — die Canvas ist ein Kritzelblock, ideal für skizzenbasierte Modelle), gr.Gallery (Raster mit Ausgabebildern — das Arbeitspferd für Image-Generation-Demos), gr.AnnotatedImage (Segmentierungs-Overlays).
• Audio:gr.Audio (Aufnahme über Mikrofon, Hochladen oder Wiedergabe — bidirektional), gr.AudioWaveform für Wellenformen mit editierbaren Bereichen, gr.Microphone — das Rückgrat von Speech-to-Text- und TTS-Demos.
• Video:gr.Video (Hochladen und Wiedergabe), nützlich für Action-Recognition- und Generierungs-Demos.
• Daten:gr.Dataframe (interaktive, editierbare Tabellen — die Brücke zwischen ML und Analytics), gr.JSON (strukturierte Ausgaben — essenziell für LLM-Tool-Calls und API-ähnliche Ergebnisse), gr.File (beliebige Uploads), gr.Model3D (3D-Meshes anzeigen und drehen — der Standard für NeRFs und Depth-Modelle) [2].
• Mediengenerierung:gr.ImageEditor (kombinierte Upload-, Canvas- und Masken-Ebenen — die native Oberfläche für Inpainting- und Bildbearbeitungsmodelle), gr.Code (sprachsensibler Code-Editor für Code-Generierungs-Demos), gr.HTML und gr.Markdown (Rich Text und benutzerdefiniertes Markup), gr.Plot (Matplotlib-/Bokeh-/Plotly-Figuren), gr.HighlightedText (Token-Hervorhebung im NER-Stil), gr.Chatbot (die Chat-Bubble-Komponente, das Herz jeder LLM-Oberfläche).

Die praktische Konsequenz: Was auch immer Ihr Modell verarbeitet oder ausgibt — Pixel, Schallwellen, Netze, Tabellen, Chatverläufe — es gibt eine erstklassige Komponente dafür, und sie funktioniert einfach. Sie kämpfen nie mit einem generischen Widget, um es zur Annahme einer Audiodatei oder zur Darstellung einer Segmentierungsmaske zu bewegen.

gr.Blocks: wenn eine Funktion nicht ausreicht

Nicht jede Anwendung ist eine einzelne Funktion. Bildbearbeitungspipelines verketten einen Generierungsschritt mit einem Verfeinerungsschritt. Interne Tools kombinieren Upload, Vorschau und Export. Modellvergleichs-Apps zeigen zwei Ausgaben nebeneinander an. Für alles, was über die Ein-Funktions-Demo hinausgeht, bietet Gradio gr.Blocks — eine Layout-Engine, mit der Sie Komponenten in beliebige Anordnungen bringen und mit Events verknüpfen [2].

import gradio as gr

with gr.Blocks() as demo:
    with gr.Row():
        with gr.Column():
            prompt = gr.Textbox(label="Prompt")
            btn = gr.Button("Generate")
        with gr.Column():
            output = gr.Image(label="Result")

    btn.click(generate, inputs=prompt, outputs=output)

demo.launch()

Die with Blöcke legen das Layout fest: gr.Row(), gr.Column(), gr.Tab(), gr.Accordion(), gr.Group() ergeben die Seite, und Event-Methoden (.click(), .change(), .submit()) verbinden Eingaben mit Ausgaben über Ihre Python-Funktionen. Das mentale Modell lautet „Layout als Kontext, Events als Verdrahtung“ — und es ist bemerkenswert kompakt für die Leistung, die es bietet.

Events: das vollständige Interaktivitätsmodell

Gradio-Events bieten ein umfangreiches Vokabular, das jedes Interaktionsmuster abdeckt:

• .click() — bei Klick auf den Button (das Arbeitspferd).
• .change() — wenn sich der Wert einer Komponente ändert (Eingabe, Auswahl, Upload).
• .input() — feuert während der Eingabe, live.
• .submit() — Absenden im Formularstil (denken Sie an Enter in einem Textfeld).
• .select() — wenn der Nutzer ein Element auswählt (z. B. eine Zeile in einem Dataframe, ein Bild in einer Galerie).
• .upload() — wenn eine Datei hochgeladen wird.
• .play() / .pause() / .stop() — Mediensteuerungsereignisse bei Audio-/Videoplayern.
• gr.on() — eine Low-Level-API für mehrere Auslöser.

Ereignisse lassen sich auch zu mehrstufigen Abläufen verketten: Die Ausgabe eines Ereignisses kann als Eingabe eines anderen Bausteins dienen, sodass Pipelines entstehen, die mehrere Funktionen nacheinander mit sichtbaren Zustandsänderungen ausführen. Kombiniert mit Streaming-Ausgaben (stream=True), ermöglicht das Live-Chat-Antworten, die Token für Token erscheinen [2].

Zustand und Warteschlangen: Apps mit echtem Gefühl

Zwei Mechanismen machen aus Gradio mehr als ein Demo-Spielzeug: eine Anwendungsplattform. State ermöglicht das Speichern von Daten pro Sitzung — übergibt man ein gr.State Objekt an die Funktion, serialisiert Gradio es und liefert es bei jedem Aufruf an dieselbe Sitzung zurück. So merken sich mehrstufige Gespräche den Kontext, ein Assistent behält frühere Schritte im Gedächtnis und ein Editor verfolgt das aktuelle Dokument. State ist auf die Browser-Sitzung beschränkt, sodass Nutzer-Sitzungen vollständig voneinander isoliert sind.

Und demo.queue() fügt die integrierte Warteschlange von Gradio hinzu: Anfragen werden der Reihe nach mit Fortschrittsanzeige abgearbeitet — unverzichtbar, wenn Inferenz langsam ist oder GPUs geteilt werden. queue(default_concurrency_limit=N) regelt, wie viele Jobs parallel laufen — der Hebel, den man zieht, wenn ein Modell nicht von zehn gleichzeitigen Generationen überlastet werden darf.

Teilen: von localhost zur Welt mit einem Flag

Jede Demo ist standardmäßig teilbar. demo.launch(share=True) erzeugt eine temporäre öffentliche URL über den von Gradio bereitgestellten Share-Tunnel, der über deren Server auf Ihren Rechner leitet — kein Deployment, keine Domain, keine Firewall-Konfiguration. Sie schicken den Link in einen Chat, und jemand auf der anderen Seite der Welt testet gerade Ihr Modell. Das ist die schnellste Feedbackschleife im Machine Learning, und deshalb ist die Frage „Kannst du es vorführen?“ keine beängstigende mehr.

Für permanentes Hosting lautet die Antwort Hugging Face Spaces. Ein Space ist ein Git-Repository, das Gradio (oder Streamlit oder ein Dockerfile) als gehostete App ausführt — Sie git push und huggingface.co/some-model-demo ist mit HTTPS, Ressourcen-Skalierung und einem einbettbaren Widget live. Die Integration ist First-Party und nahtlos: Gradio wurde mit Blick auf Spaces entwickelt, und Spaces ist der Ort, an dem die überwiegende Mehrheit öffentlicher ML-Demos läuft [2].

Theming: von Standardgrau zur eigenen Marke in Minuten

Gradio-Apps sahen früher nach Gradio-Apps aus — funktional, sauber und unverkennbar. Gradio v4+ hat das geändert mit gr.themes: Sie können ein vorgefertigtes Theme nutzen (gr.themes.Soft(), gr.themes.Monochrome(), gr.themes.Base()) oder ein eigenes erstellen, indem Sie Tokens durch Subklassenbildung und Überschreiben anpassen — Primärfarbe, Hintergrund, Schriftart, Radien, Abstände. Die Theming-API ist tokenbasiert, sodass Sie eine ganze App mit wenigen Zeilen umgestalten:

import gradio as gr

my_theme = gr.themes.Base()\
    .set(primary_hue="orange")

with gr.Blocks(theme=my_theme) as demo:
    ...

Sie können sogar Theme-Tokens pro Komponente mit dem elem_id und benutzerdefinierten CSS-Parametern überschreiben. Bei einer Demo, die Stakeholder beeindrucken soll, verwandeln zwei Minuten Theming eine Standard-App in etwas, das designed aussieht.

Das Plädoyer für Platz 1: Gradio gegen Streamlit gegen Dash

Gradio ist nicht das einzige Python-zu-Web-Tool, und es wäre unehrlich, das zu behaupten. Aber für die spezifische Aufgabe, Machine-Learning-Modelle vor Menschen zu bringen, ist es das beste existierende Werkzeug — und hier ist die ehrliche Begründung, Punkt für Punkt:

Gradio gegen Streamlit

Streamlit ist ein hervorragendes Framework für allgemeine Daten-Apps: Es glänzt bei Dashboards, Datenexploration und internen Analysetools — wenn Ihre Hauptausgabe Tabellen und Diagramme sind, ist Streamlit wirklich stark. Aber speziell für ML-Schnittstellen sind die Gradio-Komponenten die ML-Datentypen: gr.ImageEditor mit integriertem Masking, gr.Audio mit Browser-interner Aufzeichnung, gr.Model3D, Galerie-Raster und eine Chatbot-Komponente, die speziell für LLMs entwickelt wurde. In Streamlit bauen Sie eine Modell-Demo aus generischen Widgets zusammen; in Gradio bauen Sie sie aus den Widgets, die Ihr Modell tatsächlich benötigt. Gradio hat auch die tiefere Machine-Learning-Tradition — das Ökosystem um Hugging Face Spaces ist effektiv darauf aufgebaut, weshalb die Konvention „Demo eines Modells“ push to a Spacelautet, nicht „Streamlit-Cloud-App aufsetzen“ [2]. Für reine Daten-Dashboards nehmen Sie Streamlit; für ML-Schnittstellen gewinnt Gradio.

Gradio gegen Dash

Dash (von Plotly) ist der Enterprise-Schwertransporter: Callback-Graphen, produktionsreife Enterprise-Dashboards und kommerzieller Support. Es ist ein ernsthaftes Werkzeug für ernsthafte Analyseprodukte. Doch es verlangt deutlich mehr Boilerplate und ist nicht auf ML-Daten ausgelegt — eine Dash-App, die Audio streamt oder Bilder bearbeitet, ist ein Projekt, kein Wochenendvorhaben. Für Enterprise-Analytics im großen Maßstab hat Dash seinen Platz; für die ML-Interface-Schicht sind das Gradio-Komponentenmodell und die Spaces-Integration schlicht direkter.

Das Urteil Nummer eins

• Schnellste Demo-Bereitschaft: eine funktionierende ML-Schnittstelle in unter einer Minute schlägt alles im Ökosystem.
• ML-native Komponenten: über 40 typisierte Komponenten, entwickelt für ML-Daten — kein anderes Framework kommt auch nur annähernd heran [2].
• Tiefste Ökosystem-Integration: erstklassige Hugging Face Spaces-Hosting, Share-Links und die Model-Hub-Konvention [2].
• Spezialisierte LLM-Schicht: gr.ChatInterface liefert Ihnen eine produktionsreife Chat-UI gratis — die prägende Schnittstelle der aktuellen KI-Ära.
• Bewährt im großen Maßstab: die Standardschnittstelle der offenen KI-Plattform, genutzt von Millionen Demo-Besuchern [3].

Wann Gradio nicht die richtige Wahl ist (Ehrlichkeitsabschnitt)

Gradio ersetzt kein Produktteam. Wenn Sie ein vollständiges SaaS-Produkt mit komplexen authentifizierten Workflows, Abrechnung und einem maßgeschneiderten Design-System aufbauen, brauchen Sie wahrscheinlich ein echtes Frontend-Framework — React, ein richtiges Design-System und eine API-Schicht. Gradio treibt gerne Ihren internen Prototypen und Ihre Modell-Demo an, aber es wird weder Ihre Marketing-Website noch Ihre Kunden-Account-Flows ersetzen.

Ähnlich verhält es sich, wenn Ihr Kernbedarf in interaktiver Datenanalyse mit tiefgreifendem Dashboarding liegt — korrelierte Charts, Drill-downs, Pivot-Tabellen: Dann sind Streamlit oder Dash die bessere Wahl. Die analytischen Komponenten von Gradio (Dataframe, Plot) sind gut, aber nicht sein Schwerpunkt. Und für hochkonkurrierende Produktionsendpunkte, die Millionen API-Aufrufe bedienen, werden Sie weiterhin eine spezialisierte Serving-Schicht (Triton, vLLM, ein FastAPI-Service) benötigen — mit Gradio als menschengerichteter Benutzeroberfläche darüber. Die ehrliche Zusammenfassung: Gradio ist die Nr. 1 als Interface-Schicht für Machine Learning, und es ist kein allgemeines Web-Framework.

Deployment-Pfade: vom Prototyp zur Produktion

• Lokale Demo:demo.launch() — localhost unter :7860.
• Sofortiger Share:demo.launch(share=True) — temporärer öffentlicher Link über den Gradio-Tunnel. Ideal für eine Stakeholder-Präsentation.
• Hugging Face Spaces: — permanentes Hosting mit HTTPS, kostenloser CPU-Stufe und GPU-Upgrades. Die kanonische Heimat für ML-Demos [2].
• Docker / selbst gehostet: — Ihre App in einen Container verpacken und in jeder Cloud (AWS, GCP, Azure, Ihr eigener Rack) deployen. Gradio dient eine Standard-HTTP-App aus, sodass Reverse-Proxys und Load-Balancer einfach funktionieren.
• Gradio-Endpunkte: — jede App stellt automatisch eine HTTP-API bereit, sodass Sie Ihre Demo programmatisch aufrufen können — eine kostenlose Bonus-API-Schicht für Skripte und Integrationen.

Best Practices für Produktions-Gradio-Apps

1. Warteschlange aktivieren: demo.queue() — sie serialisiert schwere Inferenz, zeigt Fortschritt an und verhindert GPU-Überlastung unter Last.
2. Typisierte Komponenten verwenden: explizite gr.Image(type="pil") statt String-Kürzel übergeben, damit Ihre Funktion vorhersehbare Eingaben erhält.
3. Inferenz in einer Funktion halten: Modell-Laden (einmalig beim Import) von Inferenz pro Anfrage (innerhalb des Event-Handlers) trennen.
4. Lange Ausgaben streamen: bei LLMs und Generierung stream=True oder generator verwenden, damit Nutzer die Ausgabe während der Erstellung sehen, nicht erst nach dem Warten.
5. Zustand explizit erfassen: gr.State für alles nutzen, was über mehrere Interaktionen hinweg bestehen muss, und ihn auf die Session beschränken.
6. Grenzen setzen: max_file_size bei Uploads und sinnvolle Standardwerte bei Schiebereglern festlegen, um die Demo robust gegen Missbrauch zu machen.
7. Design anpassen: zwei Minuten in gr.themes investieren verdoppelt die wahrgenommene Qualität — eine gebrandete Demo wirkt wie ein Produkt, nicht wie ein Experiment.

Die API-Spickzettel

import gradio as gr

# 1. The one-function demo
interface = gr.Interface(fn=predict, inputs="image", outputs="label")

# 2. Custom layout with events
with gr.Blocks(theme=gr.themes.Soft()) as demo:
    with gr.Row():
        inp = gr.Textbox(label="Prompt")
        btn = gr.Button("Run")
    out = gr.Image(label="Output")
    btn.click(fn, inputs=inp, outputs=out)

# 3. Chat interface (LLMs)
chat = gr.ChatInterface(fn=respond, type="messages")

# 4. State + queue
with gr.Blocks() as demo:
    counter = gr.State(0)
    ...  # pass counter in/out to persist

demo.queue().launch(share=True)

Das Fazit

Ein Modell ist nicht fertig, bis ein Mensch es nutzen kann. Gradio ist der schnellste, vollständigste und bestunterstützte Weg, das zu erreichen — und genau deshalb ist es die Nummer-eins-Schnittstellenschicht für Machine Learning.

Starten Sie mit gr.Interface und liefern Sie in Minuten eine Demo aus. Wachsen Sie hinein in gr.Blocks für echte Anwendungen und gr.ChatInterface für das LLM-Zeitalter. Teilen Sie es mit einem Flag, hosten Sie es dauerhaft auf Spaces und geben Sie Ihrem Modell die Schnittstelle, die es verdient. Entstanden 2019 in Stanford, seit 2021 von Hugging Face betreut und heute die Standardmethode, mit der die Welt KI berührt [3] — Gradio ist die Schicht, die Machine Learning von etwas, über das man liest, zu etwas gemacht hat, das man anklickt.

Quellen

• Offizielle Gradio-Dokumentation: https://gradio.app/
• Gradio-Changelog (Ära Gradio 5): https://gradio.app/changelog
• Einführung in Gradio für interaktive Anwendungen (PyImageSearch): https://pyimagesearch.com/2025/02/03/introduction-to-gradio-for-building-interactive-applications/
• Geschichte und Übernahme von Gradio (AI Wiki): https://aiwiki.ai/wiki/gradio (entstanden 2019 von Abubakar Abid an der Stanford; Übernahme durch Hugging Face im Dezember 2021)
• Gradio-GitHub-Repository: https://github.com/gradio-app/gradio
• Hugging Face Spaces (Gradio-Hosting): https://huggingface.co/spaces
• Hugging Face übernimmt Gradio (Hacker-News-Thread): https://news.ycombinator.com/item?id=29581619