# Audio-Course

## Docs

- [Introducción a los datos de audio](https://huggingface.co/learn/audio-course/es/chapter1/audio_data.md)
- [Cargar y explorar una base de datos de audio](https://huggingface.co/learn/audio-course/es/chapter1/load_and_explore.md)
- [Sigue aprendiendo](https://huggingface.co/learn/audio-course/es/chapter1/supplemental_reading.md)
- [Streaming datos de audio](https://huggingface.co/learn/audio-course/es/chapter1/streaming.md)
- [Revisa tu comprensión del material del curso](https://huggingface.co/learn/audio-course/es/chapter1/quiz.md)
- [Preprocesamiento de un conjunto de datos de audio](https://huggingface.co/learn/audio-course/es/chapter1/preprocessing.md)
- [Unidad 1. Trabajando con datos de audio](https://huggingface.co/learn/audio-course/es/chapter1/introduction.md)
- [Clasificación de audio con una pipeline](https://huggingface.co/learn/audio-course/es/chapter2/audio_classification_pipeline.md)
- [Reconocimiento automático de la voz con pipeline](https://huggingface.co/learn/audio-course/es/chapter2/asr_pipeline.md)
- [Ejercicio práctico](https://huggingface.co/learn/audio-course/es/chapter2/hands_on.md)
- [Unidad 2. Una introducción amigable a las aplicaciones de audio](https://huggingface.co/learn/audio-course/es/chapter2/introduction.md)
- [¡Bienvenido al curso de Hugging Face de Audio!](https://huggingface.co/learn/audio-course/es/chapter0/introduction.md)
- [¡Únete a la comunidad!](https://huggingface.co/learn/audio-course/es/chapter0/community.md)
- [Prepárate para tomar el curso](https://huggingface.co/learn/audio-course/es/chapter0/get_ready.md)

### Introducción a los datos de audio
https://huggingface.co/learn/audio-course/es/chapter1/audio_data.md

# Introducción a los datos de audio

Por naturaleza, una onda sonora es una señal continua, es decir, que contiene un número infinito de valores de la señal en un tiempo determinado.
Este es un problema para los dispositivos digitales que trabajan con un número finito de valores. La onda sonora necesita ser convertida en 
un serie de valores discretos para que pueda ser procesada, almacenada y transmitida por un por un dispositivo digital, esta representación discreta
se conoce como representación digital.

Si exploras cualquier base de datos de audio, encontrarás archivos digitales con fragmentos de sonido que pueden contener narraciones o música.
Puedes encontrar diferentes formatos de archivo como `.wav` (Waveform Audio File), `.flac` (Free Lossless Audio Codec) 
 y `.mp3` (MPEG-1 Audio Layer 3). Estos formatos difieren principalmente en como comprimen la representación digital de la señal de audio. 

Examinemos como pasamos de una señal continua a una representación digital. La señal acústica(análoga) es primero capturada por un micrófono, 
que convierte las ondas sonoras en una señal electrica(Tambien análoga). La señal electrica es digitalizada por un 
conversor Análogo-Digital(ADC) para tener una representación digital a través del muestreo. 

## Muestreo y frecuencia de muestreo

El muestreo es el proceso de medir el valor de una señal continua en intervalos de tiempo fijos. La señal sampleada es discreta, 
ya que contiene un número finito de valores de la señal.

    

*Ilustración de un articulo de Wikipedia: [Muestreo(procesamiento de señal)](https://es.wikipedia.org/wiki/Muestreo_(se%C3%B1al))*

La **Tasa de Muestreo** (Tambien llamada frecuencia de muestreo) es el número de muestras capturadas en un segundo y es medida en unidades 
de Hertz (Hz). Para tener un punto de referencia, un audio con calidad de CD tiene una frecuencia de muestreo de 44,100 Hz, es decir que se 
capturan 44,100 muestras por segundo. Existen archivos de audio Hi-Fi que utilizan frecuencias de muestreo de 192,000 hz o 192kHz. Una
frecuencia de muestreo comúnmente usada para entrenar modelos de voz es 16,0000 Hz o 16 kHz.

La elección de la frecuencia de muestreo determina la frecuencia más alta que puede ser representada digitalmente. Esto se conoce
como el limite de Nyquist y es exactamente la mitad de la señal de la frecuencia de muestreo. Las frecuencias audibles en la voz humana
estan por debajo de 8kHz, por lo que una frecuencia de 16kHz es suficiente. Usar una frecuencia de muestreo más alta no va a capturar
más información pero si añade un costo computacional al procesamiento de estos archivos. En el caso contrario, elegir una frecuencia de 
muestreo muy baja puede resultar en perdidas de información. Audios de voz sampleados a 8kHz sonarán opacos, ya que las frecuencias por encima 
de 4kHz no pueden ser capturadas por esta frecuencia de muestreo. 

Es importante asegurar que todos los ejemplos de audio de la base de datos tienen la misma frecuencia de muestreo. Si planeas usar
tus propios audios para hacer fine-tunning de un modelo pre-entrenado, la frecuencia de muestreo de estos audios debe concordar con 
la frecuencia de muestreo con la que el modelo fue previamente entrenado. La frecuencia de muestreo determina el intervalo de tiempo
entre muestras de audio sucesivas, lo que tiene un efecto en la resolución temporal de los datos de audio. Por ejemplo: un audio de 5 
segundos con una frecuencia de muestreo de 16,000 Hz será representado como una serie de 80,000 valores, mientras que el mismo audio con 
una frecuencia de muestreo de 8,000hz será representado como una serie de 40,000 valores. Los modelos de transformers para audio tratan los
ejemplos como secuencias y se basan en mecanismos de atención para aprender del audio o de representaciónes multimodales. Ya que la longitud 
de las secuencias difiere al usar frecuencias de muestreo diferentes, será dificil para el modelo generalizar para diferentes frecuencias de muestro. 
**Resamplear** es el proceso de convertir una señal a otra frecuencia de muestreo, es parte de la sección de [preprosesamiento](preprocessing#resampling-the-audio-data) de datos de audio.

## Amplitud y profundidad de bits

Mientras que la frecuencia de muestreo te indica con qué frecuencia se toman las muestras, ¿Qué representan exactamente los valores en cada muestra?

El sonido se produce por cambios en la presión del aire a frecuencias audibles para los humanos. La **amplitud** de un sonido describe el nivel
de presión sonora en un momento dado y se mide en decibelios (dB). Percibimos la amplitud como volumen o intensidad del sonido. Por ejemplo, 
una voz normal al hablar está por debajo de los 60 dB, mientras que un concierto de rock puede llegar a los 125 dB, alcanzando 
los límites de la audición humana.

En el audio digital, cada muestra de audio registra la amplitud de la onda de audio en un momento específico. La profundidad de bits de 
la muestra determina con qué precisión se puede describir este valor de amplitud. Cuanto mayor sea la profundidad de bits, más fiel será la
representación digital a la onda de sonido continua original.

Las profundidades de bits de audio más comunes son 16 bits y 24 bits. Cada una es una medida binaria que representa el número de pasos posibles 
en los que se puede cuantificar el valor de amplitud al convertirlo de continuo a discreto: 65.536 pasos para el audio de 16 bits 
y 16.777.216 pasos para el audio de 24 bits. Debido a que la cuantificación implica redondear el valor continuo a un valor discreto, el proceso 
de muestreo introduce ruido. Cuanto mayor sea la profundidad de bits, menor será este ruido de cuantificación. En la práctica, el ruido de 
cuantificación del audio de 16 bits ya es lo suficientemente pequeño como para ser audible, por lo que generalmente no es
 necesario utilizar profundidades de bits más altas.

También es posible encontrarse con audio de 32 bits. Este almacena las muestras como valores de punto flotante, mientras que el audio
de 16 bits y 24 bits utiliza muestras enteras. La precisión de un valor de punto flotante de 32 bits es de 24 bits, lo que le otorga 
la misma profundidad de bits que el audio de 24 bits. Se espera que las muestras de audio de punto flotante se encuentren dentro del 
rango [-1.0, 1.0]. Dado que los modelos de aprendizaje automático trabajan naturalmente con datos de punto flotante, el audio debe convertirse
primero al formato de punto flotante antes de poder ser utilizado para entrenar el modelo. Veremos cómo hacer esto en la próxima sección
 sobre Preprocesamiento.

Al igual que con las señales de audio continuas, la amplitud del audio digital se expresa típicamente en decibelios (dB). Dado que la audición
humana es de naturaleza logarítmica, es decir, nuestros oídos son más sensibles a las pequeñas fluctuaciones en sonidos silenciosos que en
sonidos fuertes, el volumen de un sonido es más fácil de interpretar si las amplitudes están en decibelios, que también son logarítmicos.
La escala de decibelios para el audio real comienza en 0 dB, que representa el sonido más silencioso posible que los humanos pueden escuchar,
y los sonidos más fuertes tienen valores más grandes. Sin embargo, para las señales de audio digital, 0 dB es la amplitud más alta posible, 
mientras que todas las demás amplitudes son negativas. Como regla general: cada -6 dB implica una reducción a la mitad de la amplitud, y cualquier 
valor por debajo de -60 dB generalmente es inaudible a menos que subas mucho el volumen.

## Audio como forma de onda

Es posible que hayas visto los sonidos visualizados como una **forma de onda**(waveform), que representa los valores de las muestras a lo 
largo del tiempo y muestra los cambios en la amplitud del sonido. Esta representación también se conoce como la representación en 
el dominio del tiempo del sonido.

Este tipo de visualización es útil para identificar características específicas de la señal de audio, como la sincronización
de eventos de sonido individuales, la intensidad general de la señal y cualquier irregularidad o ruido presente en el audio.

Para graficar la forma de onda de una señal de audio, usamos una libreria de Python llamada `librosa`:

```bash
pip install librosa
```
Carguemos un ejemplo de la libreria llamado "trumpet":

```py
import librosa

array, sampling_rate = librosa.load(librosa.ex("trumpet"))
```

El ejemplo es cargado como una tupla formada por una serie temporal de valores de audio(llamado `array`) y la frecuencia de muestreo (`sampling_rate`).
Grafiquemos este sonido usando la función `waveshow()` de librosa:

```py
import matplotlib.pyplot as plt
import librosa.display

plt.figure().set_figwidth(12)
librosa.display.waveshow(array, sr=sampling_rate)
```

    

Esta representación grafica la amplitud de la señal en el eje y y el tiempo en el eje x. En otras palabras, cada punto corresponde 
a un único valor de muestra que se tomó cuando se muestreó este sonido. También es importante tener en cuenta que librosa devuelve
el audio en forma de valores de punto flotante y que los valores de amplitud se encuentran dentro del rango [-1.0, 1.0].

Visualizar el audio junto con escucharlo puede ser una herramienta útil para comprender los datos con los que estás trabajando. 
Puedes observar la forma de la señal, identificar patrones y aprender a detectar ruido o distorsión. 
Si preprocesas los datos de alguna manera, como normalización, remuestreo o filtrado, puedes confirmar visualmente que los pasos 
de preprocesamiento se hayan aplicado correctamente.

Después de entrenar un modelo, también puedes visualizar las muestras donde se producen errores (por ejemplo, en una tarea de 
clasificación de audio) para solucionar el problema. Esto te permitirá depurar y entender mejor las áreas en las que el modelo
puede tener dificultades o errores.

## El espectro de frecuencia

Otra forma de visualizar los datos de audio es graficar el espectro de frecuencia de una señal de audio,
 también conocido como la representación en el dominio de la frecuencia. El espectro se calcula utilizando la transformada 
 discreta de Fourier o DFT. Describe las frecuencias individuales que componen la señal y su intensidad.

Grafiquemos el espectro de frecuencia para el mismo sonido de trompeta mediante el cálculo de la transformada discreta de Fourier (DFT)
utilizando la función rfft() de numpy. Si bien es posible trazar el espectro de toda la señal de audio, es más útil observar una pequeña
región en su lugar. Aquí tomaremos la DFT de los primeros 4096 valores de muestra, que es aproximadamente la duración de la primera nota
que se está tocando:

```py
import numpy as np

dft_input = array[:4096]

# calcular la DFT
window = np.hanning(len(dft_input))
windowed_input = dft_input * window
dft = np.fft.rfft(windowed_input)

# obtener la amplitud del espectro en decibeles
amplitude = np.abs(dft)
amplitude_db = librosa.amplitude_to_db(amplitude, ref=np.max)

# Obtener los bins de frecuencia
frequency = librosa.fft_frequencies(sr=sampling_rate, n_fft=len(dft_input))

plt.figure().set_figwidth(12)
plt.plot(frequency, amplitude_db)
plt.xlabel("Frequency (Hz)")
plt.ylabel("Amplitude (dB)")
plt.xscale("log")
```

    

Esto representa la intensidad de los diferentes componentes de frecuencia que están presentes en este segmento de audio.
Los valores de frecuencia se encuentran en el eje x, generalmente representados en una escala logarítmica, mientras que
las amplitudes se encuentran en el eje y.

El espectro de frecuencia que hemos graficado muestra varios picos. Estos picos corresponden a los armónicos de la nota que se está tocando, 
siendo los armónicos más altos(en frecuencia) los más silenciosos. Dado que el primer pico se encuentra alrededor de 620 Hz, este es el espectro
de frecuencia de una nota Mi♭.

La salida de la DFT es una matriz de números complejos, compuestos por componentes reales e imaginarios. Tomar la magnitud con np.abs(dft)
extrae la información de amplitud del espectrograma. El ángulo entre los componentes reales e imaginarios proporciona el llamado espectro
de fase, pero esto a menudo se descarta en aplicaciones de aprendizaje automático.

Utilizamos `librosa.amplitude_to_db()` para convertir los valores de amplitud a la escala de decibelios, lo que facilita ver los detalles más
sutiles en el espectro. A veces, las personas utilizan el **espectro de potencia**, que mide la energía en lugar de la amplitud; esto es simplemente
un espectro con los valores de amplitud elevados al cuadrado.+

💡 En la práctica, las personas utilizan indistintamente los términos FFT (Transformada Rápida de Fourier) y DFT (Transformada Discreta de Fourier), 
ya que la FFT es la única forma eficiente de calcular la DFT en una computadora.

El espectro de frecuencia de una señal de audio contiene exactamente la misma información que su representación en el dominio
del tiempo(forma de onda); simplemente son dos formas diferentes de ver los mismos datos (en este caso, los primeros 4096 valores
de muestra del sonido de trompeta). Mientras que la forma de onda representa la amplitud de la señal de audio a lo largo del tiempo,
el espectro visualiza las amplitudes de las frecuencias individuales en un punto fijo en el tiempo.

## Espectrograma

¿Y si queremos ver cómo cambian las frecuencias en una señal de audio? La trompeta toca varias notas que tienen diferentes frecuencias.
 El problema es que el espectro solo es una foto fija de las frecuencias en un instante determinado. La solución es tomar múltiples DFT, 
 cada una abarcando un pequeño fragmento de la señal, y luego apilar los espectros resultantes en un **espectrograma**.

Un espectrograma grafica el contenido frecuencial de una señal de audio a medida que cambia en el tiempo. Esto nos permite ver en la 
misma gráfica la información de tiempo, frecuencia y amplitud. El algoritmo que permite hacer este representación se conoce como STFT o 
Transformada de tiempo corto de Fourier.

El espectrograma es una de las herramientas más útiles disponibles. Por ejemplo, cuando estamos trabajando con una grabación de música, 
podemos ver como contribuye cada instrumento y las voces al sonido general. En el habla, se pueden identificar los difrerentes
sonidos de las vocales ya que cada vocal esta caracterizada por frecuencias particulares. 

Grafiquemos ahora un espectrograma del mismo sonido de trompeta, usando las funciones de librosa `stft()` y `specshow()`:

```py
import numpy as np

D = librosa.stft(array)
S_db = librosa.amplitude_to_db(np.abs(D), ref=np.max)

plt.figure().set_figwidth(12)
librosa.display.specshow(S_db, x_axis="time", y_axis="hz")
plt.colorbar()
```

    

En este gráfico, el eje x representa el tiempo al igual que en la visulización de la forma de onda sin embargo el eje y ahora representa la 
frecuencia en hertz(Hz). La intensidad del color representa el nivel en decibelios (dB) de las componentes de frecuencia en cada punto del tiempo.

El espectrograma es creado al tomar pequeños segmentos de la señal de audio, comunmente de unos cuantos milisegundos y calculando
la transformada discreta de Fourier de cada segmento para obtener el espectro en frecuencia. Estos espectros se concatenan a lo 
largo del eje temporal para crear un espectrograma. Cada columna en la imagen corresponde a un espectro de frecuencia, Por defecto, 
la función `librosa.stft()` divide la señal en segmentos de 2048 muestras, lo que ofrece un buen resultado
para la resolución en frecuencia y la resolución temporal.

Dado que el espectrograma y la forma de onda son diferentes representaciones de los mismos datos, es posible convertir el 
espectrograma nuevamente en la forma de onda original utilizando la STFT inversa (transformada de Fourier de tiempo corto inversa). 
Sin embargo, esto requiere tanto la información de amplitud como la información de fase. Si el espectrograma fue generado por un
modelo de aprendizaje automático, típicamente solo se genera la información de amplitud. En ese caso, podemos utilizar un algoritmo
de reconstrucción de fase clásico como el algoritmo de Griffin-Lim, o utilizar una red neuronal llamada vocoder, para reconstruir una 
forma de onda a partir del espectrograma.

Los espectrogramas no solo se utilizan para visualización. Muchos modelos de aprendizaje automático toman espectrogramas como entrada, 
en lugar de formas de onda, y producen espectrogramas como salida.

Ahora que sabemos qué es un espectrograma y cómo se genera, echemos un vistazo a una variante ampliamente utilizada en el procesamiento 
del habla: el espectrograma de mel.

## Espectrograma de Mel

Un espectrograma mel es una variante del espectrograma que se utiliza comúnmente en el procesamiento del habla y en tareas de aprendizaje
 automático. Es similar a un espectrograma en el sentido de que muestra el contenido de frecuencia de una señal de audio a lo largo del tiempo,
  pero en un eje de frecuencia diferente.

En un espectrograma estándar, el eje de frecuencia es lineal y se mide en hercios (Hz). Sin embargo, el sistema auditivo humano
es más sensible a los cambios en las frecuencias bajas que en las frecuencias altas, y esta sensibilidad disminuye de manera logarítmica
a medida que la frecuencia aumenta. La escala mel es una escala perceptual que aproxima la respuesta de frecuencia no lineal del oído humano.

Para crear un espectrograma de mel, se utiliza la STFT de la misma manera que vimos antes, dividiendo el audio en segmentos cortos para 
obtener una secuencia de espectros de frecuencia. Además, cada espectro se pasa a través de un conjunto de filtros(banco de filtros de mel) 
para transformar las frecuencias a la escala de mel.

Obsrevemos como podemos obtener el espectrograma de mel usando la función `melspectrogram()`  de librosa, que realiza todos los pasos anteriores:

```py
S = librosa.feature.melspectrogram(y=array, sr=sampling_rate, n_mels=128, fmax=8000)
S_dB = librosa.power_to_db(S, ref=np.max)

plt.figure().set_figwidth(12)
librosa.display.specshow(S_dB, x_axis="time", y_axis="mel", sr=sampling_rate, fmax=8000)
plt.colorbar()
```

    

En el ejemplo anterior, `n_mels` representa el número de bandas de mel que se generarán. Las bandas de mel definen un conjunto de
rangos de frecuencia que dividen el espectro en componentes significativos desde el punto de vista perceptual, utilizando un
conjunto de filtros cuya forma y espaciado se eligen para imitar la forma en que el oído humano responde a diferentes frecuencias.
Los valores comunes para `n_mels` son 40 o 80. `fmax` indica la frecuencia más alta (en Hz) que nos interesa.

Al igual que con un espectrograma regular, es práctica común expresar la intensidad de los componentes de frecuencia de mel en decibelios.
 Esto se conoce comúnmente como un **espectrograma logarítmico de mel**, porque la conversión a decibelios implica una operación logarítmica. 
 El ejemplo anterior se usó `librosa.power_to_db()` ya que la función `librosa.feature.melspectrogram()` crea un espectrograma de potencia.

💡 ¡No todos los espectrogramas mel son iguales! Existen dos variantes comumente usadas de las escalas de mel("htk" y "slaney"),
, y en lugar del espectrograma de potencia, se puede estar usando el espectrograma de amplitud. El cálculo de un espectrograma 
logarítmico de mel no siempre usa decibelios reales, puede que se haya aplicado solamente la función `log`. Por lo tanto, 
si un modelo de aprendizaje automático espera un espectrograma de mel como entrada, verifica que estés calculándolo de la misma manera
 para asegurarte de que sea compatible.

La creación de un espectrograma mel es una operación con pérdidas, ya que implica filtrar la señal. Convertir un espectrograma de mel de
nuevo en una forma de onda es más difícil que hacerlo para un espectrograma regular, ya que requiere estimar las frecuencias que se eliminaron.
Es por eso que se necesitan modelos de aprendizaje automático como el vocoder HiFiGAN para producir una forma de onda a partir de un espectrograma de mel.

En comparación con un espectrograma estándar, un espectrograma mel captura características más significativas de la señal de audio para la percepción humana,
 lo que lo convierte en una opción popular en tareas como el reconocimiento de voz, la identificación de hablantes y la clasificación de géneros musicales.

Ahora que sabes cómo visualizar datos de audio, trata de ver cómo se ven tus sonidos favoritos. :)

### Cargar y explorar una base de datos de audio
https://huggingface.co/learn/audio-course/es/chapter1/load_and_explore.md

# Cargar y explorar una base de datos de audio

En este curso usaremos la libreria 🤗 Datasets para trabajar con bases de datos de audio. 🤗 Datasets es una libreria de
código abierto para descargar y preparar conjuntos de datos de todos los tipos, incluyendo audio. La libreria ofrece un 
acceso fácil a una gran cantidad de conjuntos de datos públicos almacenados en el Hugging Face Hub. Además, 🤗 Datasets incluye
multiples funcionalidades pensadas para simplificar el trabajo con conjuntos de datos de audio para investigadores y desarrolladores. 

Para empezar a trabajar con bases de datos de audio, asegurate de tener la librería 🤗 Datasets instalada:

```bash
pip install datasets[audio]
```
Una de las principales características de 🤗 Datasets es la posibilidad de descargar y preparar un conjunto de datos 
en una sola linea de código usando la función `load_dataset()`

Carguemos y exploremos un conjunto de audios llamado [MINDS-14](https://huggingface.co/datasets/PolyAI/minds14), el cual contiene
grabaciones de personas haciendo preguntas sobre sistemas electrónicos bancarios en diferentes lenguajes y dialectos. 

Para cargar MINDS-14, necesitamos copiar el identificador de la base de datos que aparece en el Hub (`PolyAI/minds14`) y pasarlo 
como argumento a la función `load_dataset`. Tambien especificaremos que solo estamos interesados en el subconjunto de inglés Australiano(`en-AU`) 
y la partición de entrenamiento("train"):

```py
from datasets import load_dataset

minds = load_dataset("PolyAI/minds14", name="en-AU", split="train")
minds
```

**Output:**
```out
Dataset(
    {
        features: [
            "path",
            "audio",
            "transcription",
            "english_transcription",
            "intent_class",
            "lang_id",
        ],
        num_rows: 654,
    }
)
```
El conjunto de datos contiene 654 audios, cada uno acompañado de su transcripción, una transcripción en inglés, y una etiqueta
que indica la intención de la pregunta de la persona. La columna de audio, contiene la información en bruto del audio. Examinemos
ahora uno de los ejemplos:

```py
example = minds[0]
example
```

**Output:**
```out
{
    "path": "/root/.cache/huggingface/datasets/downloads/extracted/f14948e0e84be638dd7943ac36518a4cf3324e8b7aa331c5ab11541518e9368c/en-AU~PAY_BILL/response_4.wav",
    "audio": {
        "path": "/root/.cache/huggingface/datasets/downloads/extracted/f14948e0e84be638dd7943ac36518a4cf3324e8b7aa331c5ab11541518e9368c/en-AU~PAY_BILL/response_4.wav",
        "array": array(
            [0.0, 0.00024414, -0.00024414, ..., -0.00024414, 0.00024414, 0.0012207],
            dtype=float32,
        ),
        "sampling_rate": 8000,
    },
    "transcription": "I would like to pay my electricity bill using my card can you please assist",
    "english_transcription": "I would like to pay my electricity bill using my card can you please assist",
    "intent_class": 13,
    "lang_id": 2,
}
```
Puedes ver que la columna de audio se compone de las siguiente información:
* `path`: La ruta al archivo de audio (`*.wav` en este caso).
* `array`: Los datos decodificados de audios, representedos como un NumPy array de 1 dimensión.
* `sampling_rate`. La frecuencia de muestreo del archivo (8,000 Hz en este ejemplo).

La columna `intent_class` es de tipo categórico codificado en enteros. Para convertir este número en una texto con significado 
podemos usar el método `int2str()`: 

```py
id2label = minds.features["intent_class"].int2str
id2label(example["intent_class"])
```

**Output:**
```out
"pay_bill"
```
Si miras la columna de `transcription`, puedes ver que en efecto la persona ha grabado un audio haciendo una pregunta sobre 
pagar una cuenta. 

Si planeas entrenar un clasificador de audio en este subconjunto de datos, no necesitas toda la información contenida en las
columnas del conjunto de datos. Por ejemplo, la información en `lang_id` sera igual para todos los ejemplos y no nos será útil. 
La columna `english_transcription' seguramente sera un duplicado de la columna `transcription` en este subconjunto, por lo que 
podemos removerla tambien.

Puedes eliminar características irrelevantes usando el método ``remove_columns`de 🤗 Datasets

```py
columns_to_remove = ["lang_id", "english_transcription"]
minds = minds.remove_columns(columns_to_remove)
minds
```

**Output:**
```out
Dataset({features: ["path", "audio", "transcription", "intent_class"], num_rows: 654})
```
Ahora que hemos cargado e inspeccionado los contenidos del conjunto de datos, ¡escuchemos algunos ejemplos! Usaremos `Blocks`
y `Audio` de `Gradio` para cargar algunos ejemplos del dataset. 

```py
import gradio as gr

def generate_audio():
    example = minds.shuffle()[0]
    audio = example["audio"]
    return (
        audio["sampling_rate"],
        audio["array"],
    ), id2label(example["intent_class"])

with gr.Blocks() as demo:
    with gr.Column():
        for _ in range(4):
            audio, label = generate_audio()
            output = gr.Audio(audio, label=label)

demo.launch(debug=True)
```
Podemos visulizar tambien algunos de los ejemplos. Grafiquemos ahora la forma de onda del primer ejemplo. 

```py
import librosa
import matplotlib.pyplot as plt
import librosa.display

array = example["audio"]["array"]
sampling_rate = example["audio"]["sampling_rate"]

plt.figure().set_figwidth(12)
librosa.display.waveshow(array, sr=sampling_rate)
```

    

¡Pruebalo! Decarga otro dialecto o lenguaje del conjunto MINDS-14, escucha y visualiza ajgunos ejemplos para tener un 
sentido de la variación de toda la base de datos. Puedes ver una lista de todos los lenguajes [aqui](https://huggingface.co/datasets/PolyAI/minds14).

### Sigue aprendiendo
https://huggingface.co/learn/audio-course/es/chapter1/supplemental_reading.md

# Sigue aprendiendo

Esta unidad abarcó muchos conceptos fundamentales que son relevantes para entender los datos de audio y trabajar con ellos.
¿Quieres aprender más? Aquí encontraras recursos adicionales que te ayudaran a profundizar en tu entendimiento de los temas
y mejorará tu experiencia de aprendizaje.

En el siguiente video, Monty Montgomery de xiph.org presenta demonstraciones en tiempo real de sampleo, cuantización,
profundidad en bits, dither y equipamiento de audio usando tanto herramientas digitales de analisis modernas como equipo vintage, 
Dale un vistazo:

Si deseas adentrarte más en el procesamiento digital de señales, echa un vistazo al libro gratuito ["Digital Signals Theory" book](https://brianmcfee.net/dstbook-site/content/intro.html) 
escrito por Brian McFee, Profesor Asistente de Tecnología Musical y Ciencia de Datos en la Universidad de Nueva York y 
principal mantenedor del paquete `librosa`.

### Streaming datos de audio
https://huggingface.co/learn/audio-course/es/chapter1/streaming.md

# Streaming datos de audio

Uno de los mayores desafíos que se enfrenta con los conjuntos de datos de audio es su gran tamaño. Un solo minuto de audio sin comprimir de calidad
 de CD (44.1kHz, 16 bits) ocupa un poco más de 5 MB de almacenamiento. Por lo general, un conjunto de datos de audio contiene horas de grabaciones.

En el ejemplo anterior usamos un subconjunto pequeño de MIND-14, sin embargo, las bases de datos de audios suelen ser mucho mas extensas.
Por ejemplo, la partición `xs`(más pequeña) de [GigaSpeech de SpeechColab](https://huggingface.co/datasets/speechcolab/gigaspeech)
aunque solo contiene 10 horas de grabaciones, su tamaño es mayor a los 13GB. ¿Qué pasa entonces cuando queremos entrenar en subconjunto
más grande? la partición `xl` de este mismo dataset contiene 10,000 horas de datos para entrenamiento, cuyo tamaño asciende a 1TB. Para la 
mayoria de nosotros, este tamaño excede las especificaiones de un disco duro tipico. ¿Necesitamos comprar almacenamiento adicional? ¿O hay alguna forma
 de entrenar con estos conjuntos de datos sin restricciones de espacio en disco?

 🤗 Datasets resuelve este reto al ofrecer el modo de transmisión (streaming). La transmisión nos permite cargar los datos de forma 
 progresiva a medida que iteramos sobre el conjunto de datos. En lugar de descargar todo el conjunto de datos de una vez, cargamos el 
 conjunto de datos un ejemplo a la vez. Iteramos sobre el conjunto de datos, cargando y preparando ejemplos sobre la marcha cuando
  se necesitan. De esta manera, solo cargamos los ejemplos que estamos utilizando y no los que no necesitamos.
  Una vez que hemos terminado con un ejemplo, continuamos iterando sobre el conjunto de datos y cargamos el siguiente.

El modo de transmisión tiene tres ventajas principales sobre el modo tradicional de descargar la base de datos completa:

* Espacio en disco: Los ejemplos son cargados en memoria uno a uno a medida que iteramos cobre el conjunto de datos. Ya que los datos
no son descargados localmente, no hay requerimientos de espacio de disco, por lo que puedes utilizar cualquier base de datos sin preocuparte 
por el tamaño. 

* Descarga y tiempo de procesamiento: Las bases de datos de audios son extensas y necesitan una cantidad considerable de 
tiempo para descargarse y procesarse. Con la funcionalidad de streaming, la carga y el procesamiento se hacen en la marcha,
lo que significa que puedes empezar a usar los audios tan pronto como el primer ejemplo este listo.

* Fácil experimentación: puedes experimentar con un subconjunto de ejemplos para verificar que tu script funciona sin tener 
que descargar la base de datos completa. 

Existe un inconveniente en el modo de transmisión. Cuando se descarga un conjunto de datos completo sin el modo de transmisión,
 tanto los datos en bruto como los datos procesados se guardan localmente en el disco. Si deseamos reutilizar este conjunto de datos, 
 podemos cargar directamente los datos procesados desde el disco, omitiendo los pasos de descarga y procesamiento. En consecuencia,
solo tenemos que realizar las operaciones de descarga y procesamiento una vez, después de lo cual podemos reutilizar los datos preparados.

Con el modo de streaming, los datos no se descargan en el disco. De esta manera, tanto los datos descargados como los datos preprocesados
no se almacenan en caché. Si deseamos reutilizar el conjunto de datos, los pasos de transmisión deben repetirse, cargando y procesando
los archivos de audio sobre la marcha nuevamente. Por esta razón, se recomienda descargar las bases de datos que es probable que 
se utilicen múltiples veces.

¿Cómo se puede habilitar el modo de transmisión? ¡Es fácil! Simplemente pasa el parámetro `streaming=True` al cargar tu conjunto de datos.
 El resto lo hara Datasets:

```py
gigaspeech = load_dataset("speechcolab/gigaspeech", "xs", streaming=True)
```
De la misma manera que se aplicaron los pasos de preprocesamiento al subconjunto descargado de MINDS-14, se puede aplicar a 
un conjunto de datos en modo streaming.

La única diferencia es que no puedes acceder a ejemplos individuales usando el indexado de Python (i.e. `gigaspeech["train"][sample_idx]`).
Al contrario, tienes que iterar sobre el conjunto de datos. A continuación puedes ver como se accede a un ejemplo del conjunto de datos 
cuando se usa streaming:

```py
next(iter(gigaspeech["train"]))
```

**Output:**
```out
{
    "segment_id": "YOU0000000315_S0000660",
    "speaker": "N/A",
    "text": "AS THEY'RE LEAVING  CAN KASH PULL ZAHRA ASIDE REALLY QUICKLY ",
    "audio": {
        "path": "xs_chunks_0000/YOU0000000315_S0000660.wav",
        "array": array(
            [0.0005188, 0.00085449, 0.00012207, ..., 0.00125122, 0.00076294, 0.00036621]
        ),
        "sampling_rate": 16000,
    },
    "begin_time": 2941.89,
    "end_time": 2945.07,
    "audio_id": "YOU0000000315",
    "title": "Return to Vasselheim | Critical Role: VOX MACHINA | Episode 43",
    "url": "https://www.youtube.com/watch?v=zr2n1fLVasU",
    "source": 2,
    "category": 24,
    "original_full_path": "audio/youtube/P0004/YOU0000000315.opus",
}
```
Si quiere previsualizar varios ejemplos de un gran conjunto de datos, usa `take()` para obtener los primeros n ejemplos. 
Obtengamos ahora 
If you'd like to preview several examples from a large dataset, use the `take()` to get the first n elements. Vamos a obtener
 los primeros dos ejemplos en el conjunto de datos de Gigaspeech:

```py
gigaspeech_head = gigaspeech["train"].take(2)
list(gigaspeech_head)
```

**Output:**
```out
[
    {
        "segment_id": "YOU0000000315_S0000660",
        "speaker": "N/A",
        "text": "AS THEY'RE LEAVING  CAN KASH PULL ZAHRA ASIDE REALLY QUICKLY ",
        "audio": {
            "path": "xs_chunks_0000/YOU0000000315_S0000660.wav",
            "array": array(
                [
                    0.0005188,
                    0.00085449,
                    0.00012207,
                    ...,
                    0.00125122,
                    0.00076294,
                    0.00036621,
                ]
            ),
            "sampling_rate": 16000,
        },
        "begin_time": 2941.89,
        "end_time": 2945.07,
        "audio_id": "YOU0000000315",
        "title": "Return to Vasselheim | Critical Role: VOX MACHINA | Episode 43",
        "url": "https://www.youtube.com/watch?v=zr2n1fLVasU",
        "source": 2,
        "category": 24,
        "original_full_path": "audio/youtube/P0004/YOU0000000315.opus",
    },
    {
        "segment_id": "AUD0000001043_S0000775",
        "speaker": "N/A",
        "text": "SIX TOMATOES ",
        "audio": {
            "path": "xs_chunks_0000/AUD0000001043_S0000775.wav",
            "array": array(
                [
                    1.43432617e-03,
                    1.37329102e-03,
                    1.31225586e-03,
                    ...,
                    -6.10351562e-05,
                    -1.22070312e-04,
                    -1.83105469e-04,
                ]
            ),
            "sampling_rate": 16000,
        },
        "begin_time": 3673.96,
        "end_time": 3675.26,
        "audio_id": "AUD0000001043",
        "title": "Asteroid of Fear",
        "url": "http//www.archive.org/download/asteroid_of_fear_1012_librivox/asteroid_of_fear_1012_librivox_64kb_mp3.zip",
        "source": 0,
        "category": 28,
        "original_full_path": "audio/audiobook/P0011/AUD0000001043.opus",
    },
]
```
El modo de transmisión puede llevar tu investigación al siguiente nivel: no solo tendrás acceso a los conjuntos de datos más grandes,
sino que también podrás evaluar sistemas en múltiples conjuntos de datos de manera simultánea sin preocuparte por el espacio en disco.
En comparación con la evaluación en un solo conjunto de datos, la evaluación en múltiples conjuntos de datos proporciona una mejor
métrica para las capacidades de generalización de un sistema de reconocimiento de voz (ver End-to-end Speech Benchmark, ESB).

### Revisa tu comprensión del material del curso
https://huggingface.co/learn/audio-course/es/chapter1/quiz.md

# Revisa tu comprensión del material del curso

### 1. En que unidades se mide la frecuencia de muestreo?

### 2. Cuando haces streaming de una gran base de datos, ¿Qué tan pronto puedes empezar a usarla?

### 3. ¿Qué es un espectrograma?

### 4. ¿Cúal es la forma más fácil de convertir una señal de audio en el espectro logarítmico de mel esperado por Whisper?

A.
```python
librosa.feature.melspectrogram(audio["array"])
```

B.
```python
feature_extractor = WhisperFeatureExtractor.from_pretrained("openai/whisper-small")
feature_extractor(audio["array"])
```

C.
```python
dataset.feature(audio["array"], model="whisper")
```

### 5.¿Cómo cargas un dataset desde el 🤗 Hub?

A.
```python
from datasets import load_dataset

dataset = load_dataset(DATASET_NAME_ON_HUB)
```

B.
```python
import librosa

dataset = librosa.load(PATH_TO_DATASET)
```

C.
```python
from transformers import load_dataset

dataset = load_dataset(DATASET_NAME_ON_HUB)
```

### 6. Tu conjunto de datos contiene audios de alta calidad con una frecuencia de muestreo de 32 kHz. Quieres entrenar un modelo de reconocimiento de voz que espera muestras de audio de 16kHz. ¿Qué debes hacer?

### 7. ¿Cómo se puede convertir un espectrograma generado por un modelo de machine learning en una forma de onda?

### Preprocesamiento de un conjunto de datos de audio
https://huggingface.co/learn/audio-course/es/chapter1/preprocessing.md

# Preprocesamiento de un conjunto de datos de audio
Cargar una base de datos con 🤗 Datasets es solo la mitad de la diversión. Si planeas usar los datos para entrenar un modelo, o 
para hacer inferencia necesitarás preprocesar los datos primero. En general, esto involucra los siguientes pasos:

* Resamplear los datos de audio.
* Filtrar la base de datos.
* Convertir el audio a la entrada esperada por el modelo. 

## Resamplear los datos de audio

La función `load_dataset` descarga los archivos de audio con la frecuencia de muestreo con la que fueron publicados. Esta frecuencia
no siempre coincide con la esperada por el modelo que planees usar para entrenar o realizar inferencia. Si existe una discrepancia 
entre las frecuencias, puedes resamplear el audio a la frecuencia de muestreo que espera el modelo.

La mayoria de los modelos pre-entrenados disponibles han sido entrenados con audios a una frecuencia de muestreo de 16kHz. 
Cuando exploramos los datos de MINDS-14, puedes haber notado que la frecuencia de muestreo era de 8kHz, por lo que seguramente
se tendrá que realizar un proceso de upsampling(Convertir de una frecuencia menor a una mayor).

Para hacer esto, usa el método `cast_column` de 🤗 Datasets. Esta operación no altera el audio cuando se ejecuta, crea una 
señal para que datasets haga el resampleo en el momento en que se carguen los audios. El siguiente código configura el proceso 
de resampling a 16 kHz.

```py
from datasets import Audio

minds = minds.cast_column("audio", Audio(sampling_rate=16_000))
```

Vuelve a cargar el primer ejemplo de audio en el conjunto de datos MINDS-14 y verifica que se haya re-muestreado al valor deseado de `sampling rate`:

```py
minds[0]
```

**Output:**
```out
{
    "path": "/root/.cache/huggingface/datasets/downloads/extracted/f14948e0e84be638dd7943ac36518a4cf3324e8b7aa331c5ab11541518e9368c/en-AU~PAY_BILL/response_4.wav",
    "audio": {
        "path": "/root/.cache/huggingface/datasets/downloads/extracted/f14948e0e84be638dd7943ac36518a4cf3324e8b7aa331c5ab11541518e9368c/en-AU~PAY_BILL/response_4.wav",
        "array": array(
            [
                2.0634243e-05,
                1.9437837e-04,
                2.2419340e-04,
                ...,
                9.3852862e-04,
                1.1302452e-03,
                7.1531429e-04,
            ],
            dtype=float32,
        ),
        "sampling_rate": 16000,
    },
    "transcription": "I would like to pay my electricity bill using my card can you please assist",
    "intent_class": 13,
}
```
Puedes ver que los valores del array ahora son diferentes. Esto es porque ahora tenemos el doble de valores de amplitud de la longitud
original.

💡 Si una señal de audio ha sido grabada a una frecuencia de muestreo de 8kHz, de manera que cada segundo de la 
señal esta representado por 8000 muestras, sabemos tambien que el audio no contiene ninguna frecuencia por encima
de 4kHz. Esto esta garantizado por el teorema de Nyquist. Resamplear a una frecuencia de muestro mayor(Upsampling) 
consiste en estimar los puntos adicionales que irian entre las muestras existentes. El proceso de Downsampling, requiere en cambio,
que primero filtremos cualquier frecuencia que sea mayor al nuevo Limite de Nyquist antes de estimar las nuevas muestras.
En otras palabras, no puedes hacer downsampling por un facto de 2x solo descartando la mitad de muestras de la señal - Esto 
crearía distorsiones en la señal llamadas alias. Hacer resampliing de la manera correcta es complejo por lo que es mejor
usar librerias que han sido probadas a lo largo de los años como lo son librosa o 🤗 Datasets.

## Filtrando el conjunto de datos

Algunas veces necesitarás filtrar los datos en función de algunos criterios. Uno de los casos comunes implica limitar los ejemplos
de audio a una duración determinada. Por ejemplo, es posible que deseemos filtrar cualquier ejemplo que supere los 20 segundos para
evitar errores de falta de memoria al entrenar un modelo.

Podemos hacer esto al usar el método `filter` que espera una función que contenga una lógica de filtrado. Empezemos por escribir
una función que indique cuales ejemplos conservar y cuales descartar. la función `is_audio_length_in_range`, retorna `True` si 
un ejemplo tiene una duracióne menor a 20s y `False` si es mayor a 20s.

```py
MAX_DURATION_IN_SECONDS = 20.0

def is_audio_length_in_range(input_length):
    return input_length 

Ahora puedes ver como se ve la entrada de audio al modelo de Whisper tras haber realizado el preprocesamiento.

La clase de extractor de características del modelo se encarga de transformar los datos de audio en bruto al formato que el modelo espera.
Sin embargo, muchas tareas que involucran audio son multimodales, como el reconocimiento de voz. En tales casos, 🤗 Transformers también 
ofrece tokenizadores específicos del modelo para procesar las entradas de texto. Para obtener más información sobre los tokenizadores,
consulta nuestro curso de [NLP](https://huggingface.co/course/chapter2/4).

Puedes cargar el extractor de características y el tokenizador para Whisper y otros modelos multimodales de forma separada, o puedes cargar
ambos usando el "procesador". Para hacer las cosas aun más simples, usa el `AutoProcessor` para cargar el extractor de características 
y el procesador de un modelo de la siguiente forma:

```py
from transformers import AutoProcessor

processor = AutoProcessor.from_pretrained("openai/whisper-small")
```

Aquí hemos ilustrado los pasos fundamentales de preparación de datos. Por supuesto, los datos personalizados pueden requerir una
preprocesamiento más complejo. En este caso, puedes ampliar la función prepare_dataset para realizar cualquier tipo de transformación
personalizada en los datos. Con 🤗 Datasets, si puedes escribirlo como una función de Python, ¡puedes aplicarlo a tu conjunto de datos!

### Unidad 1. Trabajando con datos de audio
https://huggingface.co/learn/audio-course/es/chapter1/introduction.md

# Unidad 1. Trabajando con datos de audio

## ¿Qué aprenderás?

Cada tarea de audio o voz empieza con un archivo de audio. Antes de poder resolver estas tareas, es importante 
que comprendas que tipo de información contienen estos archivos y como trabajar con ellos. 

En esta unidad, entenderás la terminología fundamental relacionada con los datos de audio, incluyendo formas de onda, 
frecuencia de muestreo y espectrograma. Tambien aprenderas como trabajar con bases de datos de audio, lo que incluye 
cargar y preprocesar datos de audio y como trabajar en modo streaming con una base de datos grande de manera eficiente.

Al finalizar esta unidad, tendrás un sólido conocimiento de la terminología esencial de los datos de audio y estarás equipado 
con las habilidades necesarias para trabajar con conjuntos de datos de audio en diversas aplicaciones. El conocimiento que adquirirás 
en esta unidad sentará las bases para comprender el resto del curso.

### Clasificación de audio con una pipeline
https://huggingface.co/learn/audio-course/es/chapter2/audio_classification_pipeline.md

# Clasificación de audio con una pipeline

La clasificación de audio consiste en asignar o más etiquetas a una grabación de audio basado en su contenido. Las etiquetas
pueden corresponder a diferentes categorias del sonido, como música, voz o ruido, o etiquetas más especificas como canto de ave o
sonido de motor de carro.

Antes de entrar en los detalles sobre el funcionamiento de los transformers más populares para audio, y antes de hacer fine-tunning 
de un modelo personalizado. Revisemos como se puede usar un modelo pre-entrenado para clasificación de audio con solo una lineas de 
código de  🤗 Transformers.

Usemos el mismo conjunto de [MINDS-14](https://huggingface.co/datasets/PolyAI/minds14) que hemos estado explorando en la 
unidad anterior. Como recordarás, MINDS-14 contiene grabaciones de personas haciendo preguntas a un sistema de banca electrónica 
en diferentes idiomas y dialectos, y tiene la etiqueta de `intent_class` para cada grabación. Podemos clasificar las grabaciones por 
la intención de la llamada.

Tal como hemos hecho antes, carguemos el subset de `en-AU` probar esta pipeline, y hagamos un upsampling a 16kHz que es 
la frecuencia de muestreo que el modelo espera. 

```py
from datasets import load_dataset
from datasets import Audio

minds = load_dataset("PolyAI/minds14", name="en-AU", split="train")
minds = minds.cast_column("audio", Audio(sampling_rate=16_000))
```

Para clasificar una grabación de audio en alguna de las clases, podemos usar la pipeline de `audio-classification` que tiene 🤗 Transformers.
En nuestro caso, necesitamos un modelo que ha sido entrenado para clasificar la intención en donde especificamente hayan la base de datos de 
MINDS-14. Afortunadamente para nosotros, el Hub tiene un modelo que hace justamente esto. Carguemoslo usando la función `pipeline()`:

```py
from transformers import pipeline

classifier = pipeline(
    "audio-classification",
    model="anton-l/xtreme_s_xlsr_300m_minds14",
)
```
Esta pipeline espera los datos de audio como un array de Numpy. Todo el preprocesamiento de los datos de audio será hecha por 
la pipeline. Seleccionemos un ejemplo para probarlo:

```py
example = minds[0]
```
Si recuerdas la estructura del conjunto de datos, los datos en bruto de audio se almacenan en un array de Numpy en 
la columna `["audio"]["array"]`, que podemos pasar directamente al  `classifier`:

```py
classifier(example["audio"]["array"])
```

**Output:**
```out
[
    {"score": 0.9631525278091431, "label": "pay_bill"},
    {"score": 0.02819698303937912, "label": "freeze"},
    {"score": 0.0032787492964416742, "label": "card_issues"},
    {"score": 0.0019414445850998163, "label": "abroad"},
    {"score": 0.0008378693601116538, "label": "high_value_payment"},
]
```
Este modelo esta bastante seguro que la intención al llamar fue preguntar sobre el pago de una cuenta. Revisemos que la
etiqueta original para este ejemplo es:

```py
id2label = minds.features["intent_class"].int2str
id2label(example["intent_class"])
```

**Output:**
```out
"pay_bill"
```
¡Hurra! la etiqueta predecida por el modelo ¡era la correcta! Aqui tuvimos suerte de encontrar un modelo que tenia exactamente 
las etiquetas que necesitabamos. La mayoria de las veces, cuando estamos tratando con una tarea de clasificación, el conjunto de clases
de un modelo pre-entrenado no son exactamente las que necesitamos. En este caso, puedes hacer un fine-tunning del modelo pre entrenado
para "calibralo" a tu conjunto de clases. Aprenderemos como se puede hacer este proceso en las próximas unidad. Por ahora, echemos un
vistazo a otra tarea muy común en el procesamiento del habla, _automatic speech recognition_.

### Reconocimiento automático de la voz con pipeline
https://huggingface.co/learn/audio-course/es/chapter2/asr_pipeline.md

# Reconocimiento automático de la voz con pipeline

El reconocimiento automático de la voz(ASR) es una tarea que consiste en transcribir una grabación de audio en texto.
Esta tarea tiene numerosas aplicaciones prácticas, desde crear subtitulos para videos hasta permitir comandos de voz en
asistentes virtuales como Siri o Alexa. 

En esta sección, usaremos la pipeline  `automatic-speech-recognition` para transcribir la grabación del audio de una 
persona haciendo una pregunta sobre el pago de una cuenta usando el mismo conjunto de datos MINDS-14 que utilizamos antes.

Para empezar, carguemos el conjunto de datos y hagamos un proceso de resampling a 16kHz como se describe en
 [Audio classification with a pipeline](introduction.mdx), si no lo has hecho antes.

Para transcribir una grabación de audio, podemos usar la pipeline `automatic-speech-recognition` de 🤗 Transformers.
Instaciemos primero la pipeline:

```py
from transformers import pipeline

asr = pipeline("automatic-speech-recognition")
```
A continuación, tomamos un ejemplo del conjunto de datos y pasamos los datos en bruto de audio por la pipeline.

```py
example = minds[0]
asr(example["audio"]["array"])
```

**Output:**
```out
{"text": "I WOULD LIKE TO PAY MY ELECTRICITY BILL USING MY COD CAN YOU PLEASE ASSIST"}
```
Comparemos la salida generada por la pipeline con la transcripción que tiene este ejemplo:

```py
example["english_transcription"]
```

**Output:**
```out
"I would like to pay my electricity bill using my card can you please assist"
```

Parece que el modelo ha hecho un muy buen trabajo ¡transcribiendo el audio! Solo una palabra tiene una transcripción mala("card") 
al compararse con la transcripción original, lo que esta muy bien considerando que el hablante tiene un acento australiano, donde la letra "r"
es mucha veces muda. Habiendo aclarado esto, no recomendaria intentar pagar tu próxima cuenta de electricidad con una pescado(Traducción de cad) 

Por defecto, esta pipeline usa un modelo entrenado para reconocimientode voz en el idioma ingles, lo que se adapta a este ejemplo. 
Si quisieras intentar transcribir otro subconjunto de MINDS-14 de un lenguaje diferente, puedes encontrar un modelo de ASR 
pre-entrenado en el [🤗 Hub](https://huggingface.co/models?pipeline_tag=automatic-speech-recognition&language=fr&sort=downloads).
Puedes filtrar los modelos por tipo de tarea y luego por lenguaje. Una vez que hayas encontrado el modelo, puedes pasar el nombre
como el argumento `model` a la pipeline

Intentemoslo para la partición de Aleman de MINDS-14. Carga el subconjunto "de-DE":

```py
from datasets import load_dataset
from datasets import Audio

minds = load_dataset("PolyAI/minds14", name="de-DE", split="train")
minds = minds.cast_column("audio", Audio(sampling_rate=16_000))
```
Mira un ejemplo para verificar que la transcripción es lo que esperamos:

```py
example = minds[0]
example["transcription"]
```

**Output:**
```out
"ich möchte gerne Geld auf mein Konto einzahlen"
```
Encuentra un modelo pre-entrenado de ASR para el idioma aleman en el 🤗 Hub, instancia la pipeline, y transcribe el ejemplo:

```py
from transformers import pipeline

asr = pipeline("automatic-speech-recognition", model="maxidl/wav2vec2-large-xlsr-german")
asr(example["audio"]["array"])
```

**Output:**
```out
{"text": "ich möchte gerne geld auf mein konto einzallen"}
```

Also, stimmt's!
Cuando trabajes en resolver tu propria tarea, empezar con una pipeline simple como las que acabamos de mostrar en esta unidad 
es una herramienta valiosa que ofrece los siguientes beneficios:
- un modelo pre entrenado puede existir que ya resuelva tu tarea de una forma satisfactoria, lo que te ahorrará tiempo.
- pipeline() se encarga de todos los pasos de pre y post procesamiento, así no tienes que preocuparte en convertir los 
datos en el formato adecuado que necesita el modelo. 
- Si el resultado no es el ideal, te da un modelo de base en el que posteriormente puedes re-entrenar.
- Una vez que re-entrenes tu modelo con tus datos personalizados y lo compartas en el Hub, la comunidad podrá usarlo de forma 
rápida y fácil usando `pipeline()`, lo que hace el campo de la IA mucho más accesible.

### Ejercicio práctico
https://huggingface.co/learn/audio-course/es/chapter2/hands_on.md

# Ejercicio práctico

Este ejericio no es calificable y esta pensado para ayudarte a familiarizar con las herramientas y librerias que estaras usando a traves del curso. Si ya tienes experiencia al usar Google Colab, 🤗 Datasets, librosa y 🤗 Transformers, puedes saltar este ejercicio.

1. Crea un cuaderno de [Google Colab](https://colab.research.google.com)
2. Usa para descargar la partición train de [`facebook/voxpopuli` dataset](https://huggingface.co/datasets/facebook/voxpopuli) en el idioma de tu elección usando el modo de transmisión(streaming).
3. Obten el tercer ejemplo del subconjunto `train` y exploralo. Dadas las caracteristicas que tiene este ejemplo, ¿En cuales tareas de audio puedes usar este dataset?
4. Gráfica la forma de onda y el espectrograma.
5. Ve al [🤗 Hub](https://huggingface.co/models), y explora modelos pre-entrenados que puedan ser usados para el reconocimiento automático de la voz en el idioma de tu elección.
6. Compara la transcripción que obtienes de la pipeline con la transcripción original.

Si tienes problemas completando este ejercicio, puedes mirar la [solución](https://colab.research.google.com/drive/1NGyo5wFpRj8TMfZOIuPaJHqyyXCITftc?usp=sharing). 
¿Has descubierto algo interesante? ¿Encontraste un buen modelo? ¿Obtuviste un bello espectrograma? Comparte tus descubrimientos en Twitter. 

En el siguiente capitulo aprenderás mas acerca de las arquitecturas para audio de transformers y entrenaras tu propio modelo

### Unidad 2. Una introducción amigable a las aplicaciones de audio
https://huggingface.co/learn/audio-course/es/chapter2/introduction.md

# Unidad 2. Una introducción amigable a las aplicaciones de audio

Bienvenido a la segunda unidad del curso de audio de Hugging Face¡, Anteriormente, exploramos los conceptos fundamentales
de los datos de audio y aprendimo como trabajar con conjuntos de datos de audio usando las librerias 🤗 Datasets y 🤗 Transformers.
Discutimos diferentes conceptos como frecuencia de muestreo, amplitud, profundidad de bits, forma de onda y espectrogramas, y vimos
como preprocesar datos para un modelo pre-entrenado.

En este punto quiza estes ansioso por aprender acerca de las tareas de audio que 🤗 Transformers puede realizar, y ahora que tienes
los conocimientos fundamentales para comprenderlo todo, echemos un vistazo a unos impresionantes ejemplos de aplicaciones de audio.

* **Clasificación de Audio**: Categorizar facilmente un clip de audio. Puedes identificar si una grabación es de un ladrido de un perro 
o un maullido de gato, o a que género corresponde una cación.
* **Reconocimiento automático de voz**: Transformar un clip de audio en texto a traves de una transcripción automática. Puedes obtener
la representación en texto de una grabación en donde alguien habla. Muy útil para tomar notas!
* **Diarización de hablantes** Alguna vez te has preguntado ¿Quién habla en una grabación? con 🤗 Transformers, puedes identificar 
que persona esta hablando en un determinado tiempo del clip de audio. Imaginate ser capaz de de diferencias entre "Alice" y "Bob"
en una grabación en donde ambos estan teniendo una conversación.
* **Texto a voz**: Crear una narración a partir de un texto que puede ser usada para crear un audio book, ayuda con la accesibilidad, 
o le da la voz a un NPC en un juego. con 🤗 Transformers puedes hacer facilmente esto

En esta unidad, tu aprenderas como usar modelos pre entrenados para algunas de estas tareas usando la función `pipeline()` de 🤗 Transformers.
Especificamente, veremos como usar modelos pre-entrenados para las tareas de clasificación de audio y reconocimiento automático de la voz. 
Comencemos!

### ¡Bienvenido al curso de Hugging Face de Audio!
https://huggingface.co/learn/audio-course/es/chapter0/introduction.md

# ¡Bienvenido al curso de Hugging Face de Audio!

Querido estudiante,

Bienvenido a este curso de transformers para audio. Una y otra vez, los transformers han demostrado ser una de las arquitecturas
 de aprendizaje profundo más poderosas y versátiles, capaces de lograr resultados que son estado del arte en una amplia gama de tareas,
incluyendo el procesamiento del lenguaje natural, visión por computadora y, más recientemente, procesamiento de audio.

En este curso, exploraremos cómo se pueden aplicar los transformers a datos de audio. Aprenderás cómo utilizarlos para abordar una variedad 
de tareas relacionadas con el audio. Ya sea que estés interesado en reconocimiento de voz, clasificación de audio o generación de habla a partir 
de texto, los transformers y este curso te brindarán las herramientas necesarias.

Para que puedas tener una idea de lo que estos modelos pueden hacer, di algunas palabras en la siguiente demostración y observa
 cómo el modelo las ¡transcribe en tiempo real!

A lo largo del curso, adquirirás una comprensión de los aspectos específicos de trabajar con datos de audio.
 Aprenderás sobre diferentes arquitecturas de transformers y entrenarás tus propios transformers de audio aprovechando potentes 
 modelos pre-entrenados.

Este curso está diseñado para estudiantes con experiencia en aprendizaje profundo y familiaridad general con los transformers.
No se requiere experiencia en el procesamiento de datos de audio. Si necesitas repasar tu comprensión de los transformers,
echa un vistazo a nuestro [Curso de NLP](https://huggingface.co/course/chapter1/1), que profundiza en los fundamentos de los transformers
en detalle.

## Conoce al equipo del curso

**Sanchit Gandhi, Machine Learning Research Engineer en Hugging Face**

¡Hola! Soy Sanchit y soy un ingeniero de investigación en aprendizaje automático para audio en el equipo de código abierto de Hugging Face 🤗.
Mi enfoque principal es el reconocimiento automático de voz y la traducción, con el objetivo actual de hacer que los modelos de habla sean
 más rápidos, ligeros y fáciles de usar.

**Matthijs Hollemans, Machine Learning Engineer en Hugging Face**

Soy Matthijs, y soy un ingeniero de aprendizaje automático para audio en el equipo de código abierto de Hugging Face. También soy el autor 
de un libro sobre cómo escribir sintetizadores de sonido, y creo plug-ins de audio en mi tiempo libre.

**Maria Khalusova, Documentation & Courses at Hugging Face**

Soy María, y creo contenido educativo y documentación para hacer que los Transformers y otras herramientas de código abierto sean aún más 
accesibles. Desgloso conceptos técnicos complejos y ayudo a las personas a comenzar con tecnologías de vanguardia.

**Vaibhav Srivastav, ML Developer Advocate Engineer at Hugging Face**

Soy Vaibhav (VB) y soy un Ingeniero de Promoción para audio en el equipo de código abierto de Hugging Face.
 Investigo sobre Texto a Voz(TTS) en lenguajes con bajos recursos y ayudo a llevar el estado del arte de la investigación del habla al público general.

## Estructura del curso

El curso esta estructurado en varias unidades que cubren varios temas en profudidad:

* Unidad 1: Aprende sobre los detalles específicos de trabajar con datos de audio, incluyendo técnicas de procesamiento de audio y preparación de datos.
* Unidad 2: Conoce las aplicaciones de audio y aprende a utilizar las pipelines de 🤗 Transformers para diferentes tareas, como
 clasificación de audio y reconocimiento de voz.
* Unidad 3: Explora las arquitecturas de transformers de audio, aprende en qué se diferencian y para qué tareas son más adecuadas.
* Unidad 4: Aprende cómo construir tu propio clasificador de género musical.
* Unidad 5: Adéntrate en el reconocimiento de voz y construye un modelo para transcribir grabaciones de reuniones.
* Unidad 6: Aprende cómo generar habla a partir de texto.
* Unidad 7: Aprende cómo convertir audio a audio utilizando transformers.

Cada unidad incluye un componente teórico, donde podras adquirir un entendimiento profundo de los conceptos y técnicas.
A lo largo del curso, hay quizzes para ayudarte a evaluar to conocimiento y reforzar tu aprendizaje.
Algunos capítulos tambien incluyen ejercicios prácticos, en los que tendrás la oportunidad de aplicar todo lo que has aprendido.

Al finalizar el curso, tendras una formación sólida en el uso de transfomers para datos de audio y estarás bien 
equipado para aplicar este tipo de técnicas a un conjunto amplio de tareas relacionadas con audio.

Las unidades del curso serán publicadas en bloques consecutivos de acuerdo a la siguiente agenda:

| Unidades   | Fecha de publicación |
|---|-----------------|
| Unidad 0, Unidad 1, and Unidad 2  | Junio 14, 2023   |
| Unidad 3, Unidad 4  | Junio 21, 2023   |
| Unidad 5  | Junio 28, 2023   |
| Unidad 6  | Julio 5, 2023    |
| Unidad 7, Unidad 8  | Julio 12, 2023   |

## Rutas de aprendizaje y certificaciones

No hay una manera correcta o erronea de tomar este curso. Todos los materiales en este curso son 100% gratis, públicos y de código abierto.
Puedes tomar el curso a tu propio ritmo, sin embargo, recomendamos ir a lo largo de las unidades en orden.

Si quieres tener un certificado al final del curso, ofrecemos dos opciones:

| Tipo de certficado   | Requerimientos                                                                                   |
|---|------------------------------------------------------------------------------------------------|
| Certificado de finalización  | Completa el 80% de los ejercicios prácticos según las instrucciones.  |
| Certificado de honor  | Completa el 100% de los ejercicios prácticos según las instrucciones. |

Cada ejercicio práctico tiene unos criterios para considerarse completo. Una vez hayas completado suficientes ejericios prácticos 
para acceder a alguno de los certificados, visita la última unidad del curso para aprender como puedes obtener tu certificado. ¡Buena Suerte!

## Suscríbete al curso

Las unidades de este curso seran publicadas gradualmente en el transcurso de un par de semanas. Te animamos a que te suscribas
a las actualizaciones del curso y asi no te perderas ninguna unidad cuando sean publicadas. Los estudiantes que se suscriban a
las actualizaciones del curso serán los primeros en darse cuenta de los eventos sociales que planeammos organizar.

[SUSCRIBETE](http://eepurl.com/insvcI)

¡Disfruta el curso!

### ¡Únete a la comunidad!
https://huggingface.co/learn/audio-course/es/chapter0/community.md

# ¡Únete a la comunidad!

Te invitamos a [unirte a nuestra comunidad dinámica y amigable en Discord](http://hf.co/join/discord). Tendrás la oportunidad de conectar 
con estudiantes con intereses similares, intercambiar ideas y obtener retroalimentación valiosa en los ejercicios prácticos. Puedes hacer
tus preguntas, compartir recursos y colaborar con otros. 

Nuestro equipo también está activo en Discord y estará disponible para brindarte apoyo y orientación cuando lo necesites.
Unirte a nuestra comunidad es una excelente manera de mantenerte motivado, activo y conectado,
¡Esperamos verte allí!

## ¿Qué es Discord?

Discord es una plataforma gratuita de chat. Si has usado Slack, lo encontrarás bastante similar.
El servidor de Discord de Hugging Face es el hogar de una próspera comunidad de 18 000 expertos en IA,
estudiantes y entusiastas, a la cual puedes unirte.

## Navegando en Discord

Una vez que te hayas registrado en nuestro servidor de Discord, deberás elegir los temas que te interesan haciendo clic en #role-assignment
ubicado la izquierda. Puedes elegir tantas categorías diferentes como desees. Para unirte a otros estudiantes de este curso, asegúrate de hacer 
 clic en "ML for Audio and Speech".
Explora los canales y comparte algunas cosas sobre ti en el canal `#introduce-yourself`.

## Canales del curso de audio

Hay muchos canales enfocados en varios temas en nuestro servidor de Discord. Encontrarás a personas discutiendo artículos, organizando eventos,
 compartiendo sus proyectos e ideas, haciendo lluvia de ideas y mucho más.

Como estudiante del curso de audio, es posible que encuentres especialmente relevantes los siguientes canales:

* `#audio-announcements`: actualizaciones sobre el curso, noticias de Hugging Face relacionadas con todo lo relacionado con el audio, anuncios de eventos y más.
* `#audio-study-group`: un lugar para intercambiar ideas, hacer preguntas sobre el curso e iniciar discusiones.
* `#audio-discuss`:  un lugar general para tener discusiones sobre temas relacionados con el audio.

Además de unirte al `#audio-study-group`, ¡siéntete libre de crear tu propio grupo de estudio, aprender juntos siempre es más fácil!

### Prepárate para tomar el curso
https://huggingface.co/learn/audio-course/es/chapter0/get_ready.md

# Prepárate para tomar el curso

Esperamos que estes emocionado de empezar este curso, hemos diseñado esta página para asegurarnos que ¡tienes
todo para comenzar!

## Paso 1. Suscríbete.

Para estar al tanto de todas las actualizaciones y los eventos sociales, suscríbete al curso.

[👉 SUSCRIBETE](http://eepurl.com/insvcI)

## Paso 2. Crea una cuenta de Hugging Face.

Si aún no tienes una, crea una cuenta de Hugging Face (Es gratis). La necesitarás para completar los ejercicios 
prácticos, para recibir el certificado de finalización, explorar modelos pre-entrenados, acceder a conjuntos de datos y mucho más.

[👉 CREA TU CUENTA DE HUGGING FACE](https://huggingface.co/join)

## Paso 3. Repasa los fundamentos (si lo necesitas)

Asumimos que estas familiarizado con los conceptos básicos de deep learning y transformers. Si necesitas afianzar tu 
comprensión de transformers, mira nuestro [Curso de NLP](https://huggingface.co/course/chapter1/1).

## Paso 4. Revisa tu setup

Para realizar el curso necesitarás:
- Un computadot con conexión a internet.
- [Google Colab](https://colab.research.google.com) para los ejercicios prácticos. La versión gratuita es suficiente.

Si nunca has usado Google Colab antes, revisa la  [introducción oficial](https://colab.research.google.com/notebooks/intro.ipynb).

## Paso 5. Únete a la comunidad.

Suscríbete a nuestro servidor de Discord, el lugar donde puedes intercambiar tus ideas con tus compañeros de curso y conctactar con nosotros (El equipo de Hugging Face).

[👉 UNETE A LA COMUNIDAD DE DISCORD](http://hf.co/join/discord)

para aprender más acerda de nuestra comuninda en Discord y como sacar el mayor provecho, Mira la [siguiente página](community)
