pvharmo2/gha-lab-6255f5fc33Laboratorio di ricerca sulla sicurezza che riproduce CVE-2023-6572 (GHSA-gqvf-3hgp-5hxv): injection di comandi nella gestione di workflow_run di gradio-app/gradio in generate-changeset.yml
Artefatto di ricerca automatizzato — non è il progetto upstream.
Questo repository è un laboratorio monouso costruito da un sistema automatizzato per una tesi magistrale presso l'Université Laval sulla riproduzione di vulnerabilità pubblicate nei workflow di GitHub Actions. È uno snapshot verbatim di
gradio-app/gradioal commit1d986217f6f4fc1829e528d2afe365635788204f(2023-11-03), ridistribuito sotto la licenza del progetto stesso, il cui file è incluso invariato in questo snapshot.Il progetto upstream non è coinvolto, non è mai preso di mira, e la vulnerabilità studiata qui è già pubblica. Ogni segreto e variabile in questo repository è un valore fittizio generato casualmente — nessuna credenziale reale è presente. I riferimenti alle action e le immagini dei runner sono bloccati a ciò che risolvevano al 2023-11-03; vedi
pinning.mdnell'output dell'harness per ogni modifica apportata allo snapshot.Domande o obiezioni: [email protected]
Website | Documentation | Guides | Getting Started | Examples | 中文
Gradio è una libreria Python open-source utilizzata per creare demo e applicazioni web di machine learning e data science.
Con Gradio, puoi creare rapidamente una bellissima interfaccia utente attorno ai tuoi modelli di machine learning o al tuo flusso di lavoro di data science e permettere alle persone di "provarli" trascinando e rilasciando le proprie immagini, incollando testo, registrando la propria voce e interagendo con la tua demo, tutto tramite il browser.
Gradio è utile per:
Dimostrare i tuoi modelli di machine learning a clienti/collaboratori/utenti/studenti.
Distribuire i tuoi modelli rapidamente con link condivisibili automatici e ottenere feedback sulle prestazioni del modello.
Eseguire il debug del tuo modello in modo interattivo durante lo sviluppo utilizzando gli strumenti integrati di manipolazione degli input.
Prerequisito: Gradio richiede Python 3.8 o superiore, tutto qui!
Uno dei modi migliori per condividere il tuo modello di machine learning, API o flusso di lavoro di data science con gli altri è creare un'app interattiva che consenta ai tuoi utenti o colleghi di provare la demo nei loro browser.
Gradio ti consente di creare demo e condividerle, tutto in Python. E di solito in poche righe di codice! Quindi iniziamo.
Per far funzionare Gradio con un semplice esempio "Hello, World", segui questi tre passaggi:
1. Installa Gradio usando pip:
pip install gradio
2. Esegui il codice qui sotto come script Python o in un Jupyter Notebook (o Google Colab):
import gradio as gr
def greet(name):
return "Hello " + name + "!"
demo = gr.Interface(fn=greet, inputs="text", outputs="text")
demo.launch()
Accorciamo il nome importato a gr per una migliore leggibilità del codice che usa Gradio. Questa è una convenzione ampiamente adottata che dovresti seguire affinché chiunque lavori con il tuo codice possa capirlo facilmente.
3. La demo qui sotto apparirà automaticamente all'interno del Jupyter Notebook, oppure si aprirà in un browser su http://localhost:7860 se eseguita da uno script:
Quando sviluppi in locale, se vuoi eseguire il codice come script Python, puoi usare la CLI di Gradio per avviare l'applicazione in modalità reload, che fornirà uno sviluppo fluido e veloce. Scopri di più sul reload nella Guida all'Auto-Reloading.
gradio app.py
Nota: puoi anche eseguire python app.py, ma non fornirà il meccanismo di ricaricamento automatico.
InterfaceNoterai che per creare la demo abbiamo creato un gr.Interface. Questa classe Interface può avvolgere qualsiasi funzione Python con un'interfaccia utente. Nell'esempio precedente abbiamo visto una semplice funzione basata su testo, ma la funzione potrebbe essere qualsiasi cosa, da un generatore di musica a un calcolatore di tasse fino alla funzione di previsione di un modello di machine learning preaddestrato.
La classe core Interface viene inizializzata con tre parametri obbligatori:
fn: la funzione attorno alla quale creare un'interfaccia utenteinputs: quali componenti usare per l'input (ad es. "text", "image" o "audio")outputs: quali componenti usare per l'output (ad es. "text", "image" o "label")Diamo un'occhiata più da vicino a questi componenti usati per fornire input e output.
Abbiamo visto alcuni semplici componenti Textbox negli esempi precedenti, ma cosa succede se vuoi cambiare l'aspetto o il comportamento dei componenti dell'interfaccia utente?
Diciamo che vuoi personalizzare il campo di input di testo — ad esempio, vuoi che sia più grande e abbia un testo segnaposto. Se usiamo la classe vera e propria di Textbox invece della scorciatoia stringa, hai accesso a molta più personalizzazione tramite gli attributi dei componenti.
import gradio as gr
def greet(name):
return "Hello " + name + "!"
demo = gr.Interface(
fn=greet,
inputs=gr.Textbox(lines=2, placeholder="Name Here..."),
outputs="text",
)
demo.launch()
Supponiamo che tu abbia una funzione più complessa, con più input e output. Nell'esempio qui sotto, definiamo una funzione che accetta una stringa, un booleano e un numero, e restituisce una stringa e un numero. Osserva come passare una lista di componenti di input e output.
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"],
)
demo.launch()
Basta avvolgere i componenti in una lista. Ogni componente nella lista inputs corrisponde a uno dei parametri della funzione, in ordine. Ogni componente nella lista outputs corrisponde a uno dei valori restituiti dalla funzione, sempre in ordine.
Gradio supporta molti tipi di componenti, come Image, DataFrame, Video o Label. Proviamo una funzione immagine-a-immagine per farti un'idea!
import numpy as np
import gradio as gr
def sepia(input_img):
sepia_filter = np.array([
[0.393, 0.769, 0.189],
[0.349, 0.686, 0.168],
[0.272, 0.534, 0.131]
])
sepia_img = input_img.dot(sepia_filter.T)
sepia_img /= sepia_img.max()
return sepia_img
demo = gr.Interface(sepia, gr.Image(width=200, height=200), "image")
demo.launch()
Quando usi il componente Image come input, la tua funzione riceverà un array NumPy con forma (height, width, 3), dove l'ultima dimensione rappresenta i valori RGB. Restituiremo anche un'immagine sotto forma di array NumPy.
Puoi anche impostare il tipo di dato usato dal componente con l'argomento a parola chiave type=. Ad esempio, se vuoi che la tua funzione accetti un percorso di file di un'immagine invece di un array NumPy, il componente di input Image potrebbe essere scritto come:
gr.Image(type="filepath", shape=...)
Nota anche che il nostro componente di input Image ha un pulsante di modifica 🖉, che consente di ritagliare e fare zoom sulle immagini. Manipolare le immagini in questo modo può aiutare a rivelare bias o difetti nascosti in un modello di machine learning!
Puoi leggere di più sui numerosi componenti e su come usarli nella documentazione di Gradio.
Gradio include una classe di alto livello, gr.ChatInterface, simile a gr.Interface, ma progettata specificamente per interfacce utente chatbot. La classe gr.ChatInterface avvolge anche una funzione, ma questa funzione deve avere una firma specifica. La funzione dovrebbe accettare due argomenti: message e poi history (gli argomenti possono avere qualsiasi nome, ma devono essere in questo ordine)
message: una str che rappresenta l'input dell'utentehistory: una list di list che rappresenta le conversazioni fino a quel punto. Ogni lista interna consiste di due str che rappresentano una coppia: [input utente, risposta bot].La tua funzione dovrebbe restituire una singola risposta stringa, che è la risposta del bot al particolare input utente message.
Per il resto, gr.ChatInterface non ha parametri obbligatori (anche se diversi sono disponibili per la personalizzazione dell'interfaccia utente).
Ecco un esempio giocattolo:
import random
import gradio as gr
def random_response(message, history):
return random.choice(["Yes", "No"])
demo = gr.ChatInterface(random_response)
demo.launch()
Gradio offre due approcci per creare app:
1. Interface e ChatInterface, che forniscono un'astrazione di alto livello per creare le demo di cui abbiamo parlato finora.
2. Blocks, un'API di basso livello per progettare app web con layout e flussi di dati più flessibili. Blocks ti consente di fare cose come gestire più flussi di dati e demo, controllare dove appaiono i componenti sulla pagina, gestire flussi di dati complessi (ad es. gli output possono servire come input per altre funzioni) e aggiornare proprietà/visibilità dei componenti in base all'interazione dell'utente — sempre tutto in Python. Se questa personalizzazione è ciò di cui hai bisogno, prova Blocks!
Diamo un'occhiata a un semplice esempio. Nota come l'API qui differisca da Interface.
import gradio as gr
def greet(name):
return "Hello " + name + "!"
with gr.Blocks() as demo:
name = gr.Textbox(label="Name")
output = gr.Textbox(label="Output Box")
greet_btn = gr.Button("Greet")
greet_btn.click(fn=greet, inputs=name, outputs=output, api_name="greet")
demo.launch()
Cose da notare:
Blocks sono creati con una clausola with, e qualsiasi componente creato all'interno di questa clausola viene automaticamente aggiunto all'app.Button, e poi è stato aggiunto un event-listener click a questo pulsante. L'API per questo dovrebbe sembrarti familiare! Come un Interface, il metodo click accetta una funzione Python, componenti di input e componenti di output.Ecco un'app per darti un assaggio di ciò che è possibile con Blocks:
import numpy as np
import gradio as gr
def flip_text(x):
return x[::-1]
def flip_image(x):
return np.fliplr(x)
with gr.Blocks() as demo:
gr.Markdown("Flip text or image files using this demo.")
with gr.Tab("Flip Text"):
text_input = gr.Textbox()
text_output = gr.Textbox()
text_button = gr.Button("Flip")
with gr.Tab("Flip Image"):
with gr.Row():
image_input = gr.Image()
image_output = gr.Image()
image_button = gr.Button("Flip")
with gr.Accordion("Open for More!"):
gr.Markdown("Look at me...")
text_button.click(flip_text, inputs=text_input, outputs=text_output)
image_button.click(flip_image, inputs=image_input, outputs=image_output)
demo.launch()
Qui succede molto di più! Tratteremo come creare app Blocks complesse come questa nella sezione building with blocks per te.
Congratulazioni, ora hai familiarità con le basi di Gradio! 🥳 Vai alla nostra prossima guida per saperne di più sulle funzionalità chiave di Gradio.
Gradio è costruito con molte meravigliose librerie open-source, supportale anche tu!
Gradio è concesso in licenza sotto la Apache License 2.0 presente nel file LICENSE nella directory principale di questo repository.
Consulta anche il paper Gradio: Hassle-Free Sharing and Testing of ML Models in the Wild, ICML HILL 2019, e citalo se usi Gradio nel tuo lavoro.
@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},
}