pvharmo2/gha-lab-ee08e207a8Autorisiertes Sicherheitsforschungslabor zur Reproduktion von CVE-2024-4253 (GHSA-r897-wrpm-h4vw): Command Injection in workflow_run in gradio-app/gradio's test-functional.yml
Automatisiertes Forschungsartefakt — nicht das Upstream-Projekt.
Dieses Repository ist ein Wegwerf-Labor, das von einer automatisierten Testumgebung für eine Masterarbeit an der Université Laval zur Reproduktion veröffentlichter GitHub-Actions-Workflow-Schwachstellen erstellt wurde. Es ist eine wörtliche Momentaufnahme von
gradio-app/gradiobeim Commita81e36967c0973012e90ec7cf03b99cf3fea88ec(2024-04-30), weitergegeben unter der eigenen Lizenz dieses Projekts, deren Datei unverändert in dieser Momentaufnahme enthalten ist.Das Upstream-Projekt ist nicht beteiligt, wird niemals angegriffen, und die hier untersuchte Schwachstelle ist bereits öffentlich bekannt. Jedes Geheimnis und jede Variable in diesem Repository ist ein zufällig generierter Dummy-Wert — es sind keine echten Anmeldedaten vorhanden. Aktionsreferenzen und Runner-Images sind auf den Stand vom 2024-04-30 fixiert; siehe
pinning.mdin der Testumgebungs-Ausgabe für jede Änderung, die an der Momentaufnahme vorgenommen wurde.Fragen oder Einwände: [email protected]
Website | Documentation | Guides | Getting Started | Examples | 中文
Gradio ist ein Open-Source-Python-Paket, mit dem du schnell eine Demo oder Webanwendung für dein Machine-Learning-Modell, deine API oder eine beliebige Python-Funktion erstellen kannst. Du kannst dann mit den integrierten Freigabefunktionen von Gradio in nur wenigen Sekunden einen Link zu deiner Demo oder Webanwendung teilen. Keine JavaScript-, CSS- oder Webhosting-Kenntnisse erforderlich!
Es braucht nur ein paar Zeilen Python, um eine schöne Demo wie die obige zu erstellen. Also legen wir los 💫
Voraussetzung: Gradio erfordert Python 3.8 oder höher
Wir empfehlen, Gradio mit pip zu installieren, das standardmäßig in Python enthalten ist. Führe dies in deinem Terminal oder deiner Eingabeaufforderung aus:
pip install gradio
[!TIP] Es ist am besten, Gradio in einer virtuellen Umgebung zu installieren. Detaillierte Installationsanweisungen für alle gängigen Betriebssysteme findest du hier.
Du kannst Gradio in deinem bevorzugten Code-Editor, Jupyter-Notebook, Google Colab oder überall dort ausführen, wo du Python schreibst. Schreiben wir deine erste Gradio-App:
import gradio as gr
def greet(name, intensity):
return "Hello " * intensity + name + "!"
demo = gr.Interface(
fn=greet,
inputs=["text", "slider"],
outputs=["text"],
)
demo.launch()
[!TIP] Wir kürzen den importierten Namen von
gradiozugr, um die Lesbarkeit des Codes zu verbessern. Dies ist eine weit verbreitete Konvention, der du folgen solltest, damit jeder, der mit deinem Code arbeitet, ihn leicht verstehen kann.
Führe nun deinen Code aus. Wenn du den Python-Code in einer Datei mit dem Namen z. B. app.py geschrieben hast, führst du python app.py im Terminal aus.
Die folgende Demo öffnet sich in einem Browser auf http://localhost:7860, wenn sie aus einer Datei ausgeführt wird. Wenn du in einem Notebook arbeitest, wird die Demo eingebettet im Notebook angezeigt.
Gib deinen Namen in das Textfeld auf der linken Seite ein, ziehe den Schieberegler und drücke dann die Schaltfläche „Submit". Du solltest rechts eine freundliche Begrüßung sehen.
[!TIP] Bei der lokalen Entwicklung kannst du deine Gradio-App im Hot-Reload-Modus ausführen, der die Gradio-App automatisch neu lädt, sobald du Änderungen an der Datei vornimmst. Gib dazu einfach
gradiovor dem Dateinamen ein, stattpython. Im obigen Beispiel würdest du in deinem Terminalgradio app.pyeingeben. Erfahre mehr über Hot Reloading im Hot-Reloading-Leitfaden.
Die Interface-Klasse verstehen
Du wirst feststellen, dass du zum Erstellen deiner ersten Demo eine Instanz der gr.Interface-Klasse erstellt hast. Die Interface-Klasse ist dafür konzipiert, Demos für Machine-Learning-Modelle zu erstellen, die eine oder mehrere Eingaben akzeptieren und eine oder mehrere Ausgaben zurückgeben.
Die Interface-Klasse hat drei Kernargumente:
fn: die Funktion, um die eine Benutzeroberfläche (UI) herum erstellt werden sollinputs: die Gradio-Komponente(n), die für die Eingabe verwendet werden. Die Anzahl der Komponenten sollte der Anzahl der Argumente in deiner Funktion entsprechen.outputs: die Gradio-Komponente(n), die für die Ausgabe verwendet werden. Die Anzahl der Komponenten sollte der Anzahl der Rückgabewerte deiner Funktion entsprechen.Das fn-Argument ist sehr flexibel — du kannst jede Python-Funktion übergeben, die du mit einer UI umhüllen möchtest. Im obigen Beispiel haben wir eine relativ einfache Funktion gesehen, aber die Funktion kann alles sein, von einem Musikgenerator über einen Steuerrechner bis hin zur Vorhersagefunktion eines vortrainierten Machine-Learning-Modells.
Die Argumente input und output akzeptieren eine oder mehrere Gradio-Komponenten. Wie wir sehen werden, enthält Gradio mehr als 30 integrierte Komponenten (wie die Komponenten gr.Textbox(), gr.Image() und gr.HTML()), die für Machine-Learning-Anwendungen entwickelt wurden.
[!TIP] Für die Argumente
inputsundoutputskannst du den Namen dieser Komponenten als Zeichenfolge ("textbox") oder eine Instanz der Klasse (gr.Textbox()) übergeben.
Wenn deine Funktion mehr als ein Argument akzeptiert, wie im obigen Fall, übergib eine Liste von Eingabekomponenten an inputs, wobei jede Eingabekomponente einem der Argumente der Funktion in der richtigen Reihenfolge entspricht. Dasselbe gilt, wenn deine Funktion mehr als einen Wert zurückgibt: Übergib einfach eine Liste von Komponenten an outputs. Diese Flexibilität macht die Interface-Klasse zu einer sehr leistungsfähigen Möglichkeit, Demos zu erstellen.
Wir werden uns in unserer Serie über das Erstellen von Interfaces eingehender mit gr.Interface befassen.
Was nützt eine schöne Demo, wenn du sie nicht teilen kannst? Mit Gradio kannst du eine Machine-Learning-Demo ganz einfach teilen, ohne dich um das Hosten auf einem Webserver kümmern zu müssen. Setze einfach share=True in launch(), und es wird eine öffentlich zugängliche URL für deine Demo erstellt. Schauen wir uns unsere Beispieldemo noch einmal an, ändern aber die letzte Zeile wie folgt:
import gradio as gr
def greet(name):
return "Hello " + name + "!"
demo = gr.Interface(fn=greet, inputs="textbox", outputs="textbox")
demo.launch(share=True) # Share your demo with just 1 extra parameter 🚀
Wenn du diesen Code ausführst, wird in Sekundenschnelle eine öffentliche URL für deine Demo generiert, etwa so:
👉 https://a23dsf231adb.gradio.live
Jetzt kann jeder auf der Welt deine Gradio-Demo in seinem Browser ausprobieren, während das Machine-Learning-Modell und die gesamte Berechnung weiterhin lokal auf deinem Computer laufen.
Um mehr über das Teilen deiner Demo zu erfahren, lies unseren speziellen Leitfaden zum Teilen deiner Gradio-Anwendung.
Bisher haben wir über die Interface-Klasse gesprochen, eine High-Level-Klasse, mit der du schnell Demos mit Gradio erstellen kannst. Aber was kann Gradio sonst noch?
gr.ChatInterfaceGradio enthält eine weitere High-Level-Klasse, gr.ChatInterface, die speziell für die Erstellung von Chatbot-Benutzeroberflächen entwickelt wurde. Ähnlich wie bei Interface stellst du eine Funktion bereit, und Gradio erstellt eine voll funktionsfähige Chatbot-Benutzeroberfläche. Wenn du daran interessiert bist, einen Chatbot zu erstellen, kannst du direkt zu unserem speziellen Leitfaden zu gr.ChatInterface springen.
gr.BlocksGradio bietet auch einen Low-Level-Ansatz zum Entwerfen von Web-Apps mit flexibleren Layouts und Datenflüssen mit der gr.Blocks-Klasse. Mit Blocks kannst du z. B. steuern, wo Komponenten auf der Seite erscheinen, komplexe Datenflüsse verarbeiten (z. B. können Ausgaben als Eingaben für andere Funktionen dienen) und Eigenschaften/Sichtbarkeit von Komponenten basierend auf Benutzerinteraktionen aktualisieren — alles weiterhin in Python.
Du kannst mit gr.Blocks() sehr individuelle und komplexe Anwendungen erstellen. Zum Beispiel ist die beliebte Bildgenerierungs- Automatic1111 Web UI mit Gradio Blocks erstellt. Wir gehen in unserer Serie über das Erstellen mit Blocks tiefer auf gr.Blocks ein.
Das ist das Wesentliche der Kern-gradio-Python-Bibliothek, aber Gradio ist eigentlich so viel mehr! Es ist ein ganzes Ökosystem aus Python- und JavaScript-Bibliotheken, mit denen du Machine-Learning-Anwendungen erstellen oder sie programmatisch in Python oder JavaScript abfragen kannst. Hier sind weitere verwandte Teile des Gradio-Ökosystems:
gradio_client): Frage jede Gradio-App programmatisch in Python ab.@gradio/client): Frage jede Gradio-App programmatisch in JavaScript ab.@gradio/lite): Schreibe Gradio-Apps in Python, die vollständig im Browser laufen (kein Server nötig!), dank Pyodide.Lerne weiterhin sequenziell über Gradio mit den Gradio-Leitfäden, die Erklärungen sowie Beispielcode und eingebettete interaktive Demos enthalten. Als Nächstes: Wichtige Funktionen von Gradio-Demos.
Oder, wenn du die Grundlagen bereits kennst und nach etwas Bestimmtem suchst, kannst du in der technischeren API-Dokumentation suchen.
Wenn du einen Fehler melden oder eine Funktion anfragen möchtest, erstelle bitte ein Issue auf GitHub. Für allgemeine Fragen zur Verwendung sind wir auf unserem Discord-Server erreichbar und helfen gerne weiter.
Wenn dir Gradio gefällt, hinterlasse uns bitte einen ⭐ auf GitHub!
Gradio basiert auf vielen wunderbaren Open-Source-Bibliotheken!
Gradio ist unter der Apache-Lizenz 2.0 lizenziert, die in der Datei LICENSE im Stammverzeichnis dieses Repositorys zu finden ist.
Schau dir auch das Paper Gradio: Hassle-Free Sharing and Testing of ML Models in the Wild, ICML HILL 2019 an und zitiere es bitte, wenn du Gradio in deiner Arbeit verwendest.
@article{abid2019gradio,
title = {Gradio: Hassle-Free Sharing and Testing of ML Models in the Wild},
author = {Abid, Abubakar and Abdalla, Ali and Abid, Ali and Khan, Dawood and Alfozan, Abdulrahman and Zou, James},
journal = {arXiv preprint arXiv:1906.02569},
year = {2019},
}