Înțelegerea clasei Interface

În această secțiune, vom examina mai îndeaproape clasa Interface și vom înțelege parametrii principali folosiți pentru a crea una.

Cum să creați o Interface

Veți observa că clasa Interface are 3 parametri necesari:

Interface(fn, inputs, outputs, ...)

Acești parametri sunt:

fn: funcția de predicție care este încapsulată de interfața Gradio. Această funcție poate lua unul sau mai mulți parametri și poate returna una sau mai multe valori
inputs: tipul(tipurile) componentei de intrare. Gradio oferă multe componente pre-construite precum "image" sau "mic".
outputs: tipul(tipurile) componentei de ieșire. Din nou, Gradio oferă multe componente pre-construite de ex. "image" sau "label".

Pentru o listă completă a componentelor, consultați documentația Gradio. Fiecare componentă pre-construită poate fi personalizată prin instanțierea clasei corespunzătoare componentei.

De exemplu, așa cum am văzut în secțiunea anterioară, în loc să transmiteți "textbox" la parametrul inputs, puteți transmite o componentă Textbox(lines=7, label="Prompt") pentru a crea o cutie de text cu 7 linii și o etichetă.

Să aruncăm o privire la un alt exemplu, de data aceasta cu o componentă Audio.

Un exemplu simplu cu audio

Așa cum am menționat mai devreme, Gradio oferă multe intrări și ieșiri diferite. Deci să construim o Interface care funcționează cu audio.

În acest exemplu, vom construi o funcție audio-la-audio care primește un fișier audio și pur și simplu îl inversează.

Vom folosi pentru intrare componenta Audio. Când folosiți componenta Audio, puteți specifica dacă doriți ca source-ul audio să fie un fișier pe care utilizatorul îl încarcă sau un microfon cu care utilizatorul își înregistrează vocea. În acest caz, să o setăm la "microphone". Doar pentru distracție, vom adăuga o etichetă la Audio-ul nostru care spune “Vorbiți aici…“.

În plus, am dori să primim audio-ul ca un array numpy pentru a putea cu ușurință să îl “inversăm”. Deci vom seta "type"-ul să fie "numpy", care transmite datele de intrare ca un tuplu de (sample_rate, data) în funcția noastră.

Vom folosi și componenta de ieșire Audio care poate reda automat un tuplu cu o rată de eșantionare și un array numpy de date ca fișier audio redabil. În acest caz, nu avem nevoie să facem nicio personalizare, deci vom folosi scurtătura string "audio".

import numpy as np
import gradio as gr


def reverse_audio(audio):
    sr, data = audio
    reversed_audio = (sr, np.flipud(data))
    return reversed_audio


mic = gr.Audio(source="microphone", type="numpy", label="Vorbiți aici...")
gr.Interface(reverse_audio, mic, "audio").launch()

Codul de mai sus va produce o interfață ca cea de mai jos (dacă browserul dvs. nu vă cere permisiuni pentru microfon, deschideți demo-ul într-o filă separată.)

Acum ar trebui să puteți să vă înregistrați vocea și să vă auziți vorbind în sens invers - înfricoșător 👻!

Gestionarea intrărilor și ieșirilor multiple

Să spunem că avem o funcție mai complicată, cu intrări și ieșiri multiple. În exemplul de mai jos, avem o funcție care primește un index dropdown, o valoare slider și un număr, și returnează un eșantion audio al unui ton muzical.

Priviți cum transmitem o listă de componente de intrare și ieșire, și vedeți dacă puteți urmări ce se întâmplă.

Cheia aici este că atunci când transmiteți:

o listă de componente de intrare, fiecare componentă corespunde unui parametru în ordine.
o listă de componente de ieșire, fiecare componentă corespunde unei valori returnate.

Fragmentul de cod de mai jos arată cum trei componente de intrare se aliniază cu cei trei argumente ai funcției generate_tone():

import numpy as np
import gradio as gr

notes = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"]


def generate_tone(note, octave, duration):
    sr = 48000
    a4_freq, tones_from_a4 = 440, 12 * (octave - 4) + (note - 9)
    frequency = a4_freq * 2 ** (tones_from_a4 / 12)
    duration = int(duration)
    audio = np.linspace(0, duration, duration * sr)
    audio = (20000 * np.sin(audio * (2 * np.pi * frequency))).astype(np.int16)
    return (sr, audio)


gr.Interface(
    generate_tone,
    [
        gr.Dropdown(notes, type="index"),
        gr.Slider(minimum=4, maximum=6, step=1),
        gr.Number(value=1, label="Durata în secunde"),
    ],
    "audio",
).launch()

Metoda launch()

Până acum, am folosit metoda launch() pentru a lansa interfața, dar nu am discutat cu adevărat ce face.

În mod implicit, metoda launch() va lansa demo-ul într-un server web care rulează local. Dacă rulați codul într-un notebook Jupyter sau Colab, atunci Gradio va incorpora interfața GUI demo în notebook pentru a o putea folosi cu ușurință.

Puteți personaliza comportamentul launch() prin parametri diferiți:

inline - dacă să afișeze interfața inline în notebook-urile Python.
inbrowser - dacă să lanseze automat interfața într-o filă nouă în browserul implicit.
share - dacă să creeze un link partajabil public de pe calculatorul dvs. pentru interfață. Cam ca un link Google Drive!

Vom acoperi parametrul share în mult mai multe detalii în următoarea secțiune!

✏️ Să aplicăm!

Să construim o interfață care vă permite să demonstrați un model de recunoaștere vocală. Pentru a o face interesantă, vom accepta fie o intrare de microfon, fie un fișier încărcat.

Ca de obicei, vom încărca modelul nostru de recunoaștere vocală folosind funcția pipeline() din 🤗 Transformers. Dacă aveți nevoie de o reîmprospătare rapidă, puteți să vă întoarceți la acea secțiune din Capitolul 1. Următorul, vom implementa o funcție transcribe_audio() care procesează audio-ul și returnează transcrierea. În final, vom încapsula această funcție într-o Interface cu componentele Audio pentru intrări și doar text pentru ieșire. În ansamblu, codul pentru această aplicație este următorul:

from transformers import pipeline
import gradio as gr

model = pipeline("automatic-speech-recognition")


def transcribe_audio(audio):
    transcription = model(audio)["text"]
    return transcription


gr.Interface(
    fn=transcribe_audio,
    inputs=gr.Audio(type="filepath"),
    outputs="text",
).launch()

Dacă browserul dvs. nu vă cere permisiuni pentru microfon, deschideți demo-ul într-o filă separată.

Asta e! Acum puteți folosi această interfață pentru a transcrie audio. Observați aici că prin transmiterea parametrului optional ca True, permitem utilizatorului să ofere fie un microfon, fie un fișier audio (sau niciunul, dar asta va returna un mesaj de eroare).

Continuați să vedeți cum să vă partajați interfața cu alții!