course/pr_1213/es/chapter9/3.md

# Entender la clase Interface[[understanding-the-interface-class]]

En esta sección, veremos más de cerca la clase `Interface` y entenderemos los parámetros principales que se usan para crear una.

## Cómo crear una Interface[[how-to-create-an-interface]]

La clase `Interface` tiene 3 parámetros obligatorios:

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

Estos parámetros son:

- `fn`: la función de predicción que envuelve la interfaz de Gradio.
- `inputs`: el tipo o los tipos de componentes de entrada.
- `outputs`: el tipo o los tipos de componentes de salida.

Para obtener una lista completa de componentes, [consulta la documentación de Gradio](https://gradio.app/docs).

## Un ejemplo sencillo con audio[[a-simple-example-with-audio]]

```py
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="Speak here...")
gr.Interface(reverse_audio, mic, "audio").launch()
```

## Manejar múltiples entradas y salidas[[handling-multiple-inputs-and-outputs]]

Cuando pasas listas de componentes de entrada y salida, cada componente se alinea con un parámetro o valor devuelto en orden:

```py
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="Duration in seconds"),
    ],
    "audio",
).launch()
```

### El método `launch()`[[the-launch-method]]

De forma predeterminada, `launch()` ejecuta la demo localmente. También puedes modificarlo con parámetros como:

- `inline`
- `inbrowser`
- `share`

## ✏️ ¡Aplícalo![[lets-apply-it]]

Construyamos una interfaz para mostrar un modelo de **speech-recognition**:

```py
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()
```

Con esto ya tienes una interfaz de reconocimiento de voz funcional.