# Audio-Course

## Docs

- [Bem vindo ao curso de Áudio do Hugging Face!](https://huggingface.co/learn/audio-course/pt-BR/chapter0/introduction.md)
- [Junte-se à comunidade!](https://huggingface.co/learn/audio-course/pt-BR/chapter0/community.md)
- [Prepare-se para iniciar o curso](https://huggingface.co/learn/audio-course/pt-BR/chapter0/get_ready.md)
- [Avalie seus conhecimentos](https://huggingface.co/learn/audio-course/pt-BR/chapter1/quiz.md)
- [Unidade 1. Trabalhando com dados de áudio](https://huggingface.co/learn/audio-course/pt-BR/chapter1/introduction.md)
- [Aprenda mais](https://huggingface.co/learn/audio-course/pt-BR/chapter1/supplemental_reading.md)
- [Carregue e explore um dataset de áudio](https://huggingface.co/learn/audio-course/pt-BR/chapter1/load_and_explore.md)
- [Streaming de dados de áudio](https://huggingface.co/learn/audio-course/pt-BR/chapter1/streaming.md)
- [Pré-processamento de um dataset de áudio](https://huggingface.co/learn/audio-course/pt-BR/chapter1/preprocessing.md)
- [Introdução a dados de áudio](https://huggingface.co/learn/audio-course/pt-BR/chapter1/audio_data.md)

### Bem vindo ao curso de Áudio do Hugging Face!
https://huggingface.co/learn/audio-course/pt-BR/chapter0/introduction.md

# Bem vindo ao curso de Áudio do Hugging Face!

Caro aluno,

Bem vindo a este curso sobre o uso de transformers para áudio. Cada vez mais os transformers se provam como uma das arquiteturas deep learning mais poderosas e versáteis, capaz de alcançar resultados de ponta em uma variedade de tarefas, incluindo o processamento de linguagem natural, visão computacional, e mais recentemente, processamento de áudio.

Neste curso, nós iremos explorar como os transformers podem ser usados em dados de áudio. Você aprenderá como usá-los para lidar com uma série de tarefas relacionadas ao áudio. Se você está interessado em reconhecimento de fala, classificação de áudio, ou geração de fala a partir do texto, os transformers e este curso vão atender as suas necessidades.

Para te dar um gostinho do que esses modelos podem fazer, diga algumas palavras na demo abaixo e veja o modelo transcrevê-las em tempo real!

<iframe
	src="https://openai-whisper.hf.space"
	frameborder="0"
	width="850"
	height="450">
</iframe>

Através do curso, você entenderá detalhes do trabalho com dados de áudio, aprenderá sobre as diferentes arquiteturas de transformers e irá treinar seu próprio transformer de áudio aproveitando poderosos modelos pré-treinados.

Este curso é voltado para estudantes com algum conhecimento prévio em deep learning e transformers. Nenhuma expertise em processamento de áudio é necessária. Se você precisa revisar seu conhecimento de transformers, dê uma olhada no nosso [curso de NLP](https://huggingface.co/course/chapter1/1) que aborda em detalhes os conceitos básicos de transformers.

## Conheça a equipe do curso

**Sanchit Gandhi, Engenheiro de Pesquisa em Machine Learning no Hugging Face**

Olá! Me chamo Sanchit e sou o engenheiro de pesquisa em machine learning para áudio no time de open-source do Hugging Face 🤗. Meu foco principal é o reconhecimento e a tradução automáticos de fala, com o objetivo atual de tornar os modelos de fala mais rápidos, leves e fáceis de usar!

**Matthijs Hollemans, Engenheiro de Machine Learning no Hugging Face**

Me chamo Matthijs, e sou o engenheiro de machine learning para áudio no time de open source do Hugging Face. Eu também sou o autor do livro sobre como escrever um sintetizador de som e crio plugins de áudio no meu tempo livre.

**Maria Khalusova, Cursos & Documentação no Hugging Face**

Eu sou Maria e crio conteúdo educacional e documentação para fazer os Transformers e outras ferramentas open source ainda mais acessíveis. Eu simplifico conceitos técnicos complexos e ajudo as pessoas a iniciarem em tecnologias de ponta.

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

Me chamo Vaibhav (VB) e sou o Engenheiro Developer Advocate para áudio no time de open source do Hugging Face. Eu estudo soluções de Texto para Fala de baixo recurso e ajudo a levar pesquisas estado da arte em fala para o grande público.

## Estrutura do Curso

O curso está estruturado em várias unidades que abordam diversos tópicos em detalhes:

* [Unidade 1](https://huggingface.co/learn/audio-course/chapter1): aprenda sobre detalhes do trabalho com dados de áudio, incluindo técnicas de processamento de áudio e preparação de dados.
* [Unidade 2](https://huggingface.co/learn/audio-course/chapter2): conheça aplicações de áudio e aprenda como usar 🤗 Transformers pipelines para diferentes tarefas, como classificação de áudio e reconhecimento de fala.
* [Unidade 3](https://huggingface.co/learn/audio-course/chapter3): explore arquiteturas de transformers de áudio, aprenda como eles se diferem e para quais tarefas são mais adequados
* [Unidade 4](https://huggingface.co/learn/audio-course/chapter4): aprenda como fazer seu próprio classificador de gênero musical
* [Unidade 5](https://huggingface.co/learn/audio-course/chapter5): mergulhe no reconhecimento de fala e construa um modelo que faça transcrição de reuniões gravadas
* [Unidade 6](https://huggingface.co/learn/audio-course/chapter6): aprenda como gerar fala a partir do texto
* [Unidade 7](https://huggingface.co/learn/audio-course/chapter7): aprenda como construir aplicações do mundo real com transformers

Cada unidade inclui uma parte teórica, onde você irá compreender os conceitos e as técnicas. Ao longo do curso, nós vamos fornecer questionários para te ajudar a testar seu conhecimento e reforçar seu aprendizado. Alguns capítulos incluem exercícios práticos, onde você terá a oportunidade de testar o que você aprendeu.

No final do curso, você terá uma base sólida sobre o uso de transformers para os dados de áudio e está pronto para aplicar essas técnicas em uma varidade de tarefas relacionadas à áudio.

Este curso será lançado em vários blocos consecutivos respeitando o seguinte agendamento:

| Unidades   				  	|Data de Publicação |
|-------------------------------|-------------------|
| Unidade 0, 1 e 2  		  	| 14 de Junho 2023  |
| Unidade 3 e 4  		  		| 21 de Junho 2023  |
| Unidade 5			  		  	| 28 de Junho 2023  |
| Unidade 6  		  			| 5 de Julho 2023  	|	
| Unidade 7 e 8 		  		| 12 de Julho 2023  |

## Trilhas de aprendizado e certificação

Não existe um jeito certo ou errado de fazer este curso. Todos os materiais nesse curso são 100% gratuitos, públicos e open source.
Você pode fazer o curso no seu próprio ritmo, contudo, nós recomendamos ir na ordem numérica das unidades.

Se você quiser obter um certificado ao completar o curso, nós oferecemos duas opções:

| Tipo Certificado   | Requisitos                                                       |
|---|--------------------------------------------------------------------|
| Certificado de conclusão  | Complete 80% dos exercícios práticos conforme as instruções  |
| Certificado de honras  | Complete 100% dos exercícios práticos conforme as instruções |

Cada exercício determina seus critérios de conclusão. Quando você concluir exercícios suficiente para se qualificar para algum dos certificados, vá a última unidade para aprender como você pode obtê-lo. Bons estudos!

## Inscreva-se no curso

As unidades deste curso serão lançadas gradualmente ao longo de algumas semanas. Encorajamos você a se inscrever nas atualizações, assim você fica sabendo das unidades assim que elas forem lançadas. Ao se inscrever nas atualizações do curso, o estudante também ficará sabendo em primeira mão, sobre eventos sociais que nós planejamos realizar.

[INSCREVA-SE](http://eepurl.com/insvcI)

Aproveite o curso!

<EditOnGithub source="https://github.com/huggingface/audio-transformers-course/blob/main/chapters/pt-BR/chapter0/introduction.mdx" />

### Junte-se à comunidade!
https://huggingface.co/learn/audio-course/pt-BR/chapter0/community.md

# Junte-se à comunidade!

Convidamos você a [se juntar à nossa comunidade vibrante e solidária no Discord](http://hf.co/join/discord). Você terá a oportunidade de conhecer
alunos com interesses semelhantes, trocar ideias e receber feedback valioso sobre seus exercícios práticos. Você pode fazer perguntas,
compartilhar materiais e colaborar com outros.

Nossa equipe também está ativa no Discord e está disponível para fornecer suporte e orientação quando você precisar.
Juntar-se à nossa comunidade é uma excelente maneira de se manter motivado, engajado e conectado, e estamos ansiosos para
ver você lá!

## O que é Discord?

Discord é uma plataforma de bate-papo gratuita. Se você já usou o Slack, vai achar bastante semelhante. O servidor do Discord do Hugging Face
é o lar de uma comunidade próspera de 18.000 especialistas em IA, alunos e entusiastas dos quais você pode fazer parte.

## Navegando pelo Discord

Uma vez que você se inscreveu em nosso servidor do Discord, você precisará escolher os tópicos de seu interesse clicando em `#role-assignment`
à esquerda. Você pode escolher quantas categorias diferentes quiser. Para se juntar a outros alunos deste curso, certifique-se de
clicar em "ML for Audio" (#ml-4-audio).
Explore os canais e compartilhe algumas coisas sobre você no canal `#introduce-yourself`.

## Canais do curso de áudio

Há muitos canais focados em vários tópicos em nosso servidor do Discord. Você encontrará pessoas discutindo artigos, organizando
eventos, compartilhando seus projetos e ideias, fazendo brainstorming e muito mais.

Como um aluno do curso de áudio, você pode achar o seguinte conjunto de canais particularmente relevante:

* `#audio-announcements`: atualizações sobre o curso, notícias do Hugging Face relacionadas a tudo sobre áudio, anúncios de eventos e mais.
* `#audio-study-group`: um lugar para trocar ideias, fazer perguntas sobre o curso e iniciar discussões.
* `#audio-discuss`: um lugar geral para ter discussões sobre coisas relacionadas ao áudio.

Além de se juntar ao `#audio-study-group`, sinta-se livre para criar seu próprio grupo de estudos, aprender juntos é sempre mais fácil!


<EditOnGithub source="https://github.com/huggingface/audio-transformers-course/blob/main/chapters/pt-BR/chapter0/community.mdx" />

### Prepare-se para iniciar o curso
https://huggingface.co/learn/audio-course/pt-BR/chapter0/get_ready.md

# Prepare-se para iniciar o curso

Esperamos que você esteja animado para começar o curso, e projetamos esta página para garantir que você tenha tudo o que precisa para vir com tudo!

## Passo 1. Inscreva-se

Para ficar por dentro de todas as atualizações e eventos sociais especiais, inscreva-se no curso.

[👉 INSCREVA-SE](http://eepurl.com/insvcI)

## Passo 2. Crie uma conta no Hugging Face

Se você ainda não tem uma, crie uma conta no Hugging Face (é grátis). Você precisará dela para completar tarefas práticas, receber seu certificado de conclusão, explorar modelos pré-treinados, acessar datasets e muito mais.

[👉 CRIE UMA CONTA NO HUGGING FACE](https://huggingface.co/join)

## Passo 3. Revise os fundamentos (se necessário)

Presumimos que você esteja familiarizado com os conceitos básicos de deep learning e o uso de transformers. Se você precisar revisar seu entendimento sobre transformers, veja o nosso [Curso de NLP](https://huggingface.co/course/chapter1/1).

## Passo 4. Verifique sua configuração

Para acompanhar os materiais do curso, você precisará de:
- Um computador com conexão à internet
- [Google Colab](https://colab.research.google.com) para os exercícios práticos. A versão gratuita é suficiente. Se você nunca usou o Google Colab antes, confira este [caderno de introdução oficial](https://colab.research.google.com/notebooks/intro.ipynb?hl=pt-BR).

<Tip>

Como alternativa à versão gratuita do Google Colab, você pode usar seu próprio ambiente local ou o  Kaggle. O Kaggle Notebooks oferece um número fixo de horas de GPU e têm funcionalidades semelhantes ao Google Colab, no entanto, existem diferenças quando se trata de compartilhar seus modelos no 🤗 Hub (para completar tarefas, por exemplo). Se você decidir usar o Kaggle como sua ferramenta de escolha, confira o [notebook de exemplo do Kaggle](https://www.kaggle.com/code/michaelshekasta/test-notebook) criado por [@michaelshekasta](https://github.com/michaelshekasta). Este notebook demonstra como você pode treinar e compartilhar seu modelo treinado no 🤗 Hub.

</Tip>

## Passo 5. Junte-se à comunidade

Inscreva-se em nosso Discord, o lugar onde você pode trocar ideias com seus colegas de classe e entrar em contato conosco (a equipe do Hugging Face).

[👉 JUNTE-SE À COMUNIDADE NO DISCORD](http://hf.co/join/discord)

Para saber mais sobre nossa comunidade no Discord e como aproveitar ao máximo, confira a [próxima página](community).


<EditOnGithub source="https://github.com/huggingface/audio-transformers-course/blob/main/chapters/pt-BR/chapter0/get_ready.mdx" />

### Avalie seus conhecimentos
https://huggingface.co/learn/audio-course/pt-BR/chapter1/quiz.md

# Avalie seus conhecimentos

### 1. Em que unidades a taxa de amostragem é medida?

<Question
	choices={[
		{
			text: "dB",
			explain: "Não, a amplite é que é medida em decibéis (dB)."
		},
		{
			text: "Hz",
			explain: "A taxa de amostragem é o número de amostras coletadas em um segundo e é medida em hertz (Hz).",
			correct: true
		},
		{
			text: "bit",
			explain: "Bits são usados para a profundidade de bits (bit depth), a qual se refere ao número de bits usados para representa cada amostra coletada de um sinal de áudio",
		}
	]}
/>

### 2. Ao usar o streaming de um grande dataset de áudio, em que momento ele se torna disponível para usá-lo?


<Question
	choices={[
		{
			text: "Assim que o download de todo o dataset for concluído",
			explain: "O objetivo do streaming é a capacidade de trabalhar com os dados sem precisar baixar todo o dataset"
		},
		{
			text: "Assim que os primeiros 16 exemplos forem baixados",
			explain: "Tente novamente!"
		},
		{
			text: "Assim que o primeiro exemplo for baixado.",
			explain: "",
			correct: true
		}
	]}
/>

### 3. O que é um espectrograma?

<Question
	choices={[
		{
			text: "Um dispositivo usado para digitalizar o áudio que foi capturado por um microfone, o qual converte ondas sonoras em sinal elétrico.",
			explain: "O dispositivo usado para digitalizar um sinal elétrico como esse é chamado conversor Analógico-Digital. Tente novamente!"
		},
		{
			text: "Um gráfico que mostra como a amplitude de um sinal de áudio varia ao longo do tempo. É conhecido também como *domínio do tempo* do som",
			explain: "A descrição acima se refere a forma de onda, e não o espectograma"
		},
		{
			text: "Uma representação visual de como o espectro de frequência de um sinal varia ao longo do tempo",
			explain: "",
			correct: true
		}
	]}
/>

### 4. Qual é a maneira mais fácil de converter dados de áudio brutos em espectrograma log-mel esperado pelo 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")
```

<Question
	choices={[
		{
			text: "A",
			explain: "`librosa.feature.melspectrogram()` cria um espectograma de potência"
		},
		{
			text: "B",
			explain: "",
			correct: true
		},
		{
			text: "C",
			explain: "A Dataset não prepara as características (features) para os modelos Transformer, isso é feito pelo pré-processador do modelo"
		}
	]}
/>

### 5. Como você carrega um conjunto de dados do 🤗 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)
```

<Question
	choices={[
		{
			text: "A",
			explain: "A melhor maneira é usar a biblioteca 🤗 Datasets.",
			correct: true
		},
		{
			text: "B",
			explain: "Librosa.load é útil para carregar um arquivo de áudio individual a partir do caminho em uma tupla com as amostras de áudio e a taxa de amostragem (sampling rate), mas não um dataset inteiro com muitos exemplos e características"
		},
		{
			text: "C",
			explain: "O método load_dataset vem da biblioteca 🤗 Datasets e não dá 🤗 Transformers."
		}
	]}
/>

### 6. Seu dataset personalizado contém áudios de alta qualidade com taxa de amostragem de 32 kHz. Você quer treinar um modelo de reconhecimento de fala que espera que os exemplos de áudio tenham uma taxa de amostragem de 16 kHz. O que você deve fazer?


<Question
	choices={[
		{
			text: "Use os exemplos como estão, o modelo generalizará facilmente para exemplos de áudio de maior qualidade.",
			explain: "Devido à dependência de mecanismos de atenção, é desafiador para os modelos generalizarem entre taxas de amostragem."
		},
		{
			text: "Use o módulo Áudio da biblioteca 🤗 Datasets para reduzir a amostragem dos exemplos no conjunto de dados personalizado",
			explain: "",
			correct: true
		},
		{
			text: "Reduza a amostragem (downsample) por um fator de 2x descartando cada uma das outras amostra.",
			explain: "Isso criará distorções no sinal chamadas de aliasing. Fazer a reamostragem (resampling) corretamente é complicado e é melhor deixar para bibliotecas bem testadas, como librosa ou 🤗 Datasets."
		}
	]}
/>

### 7. Como você pode converter um espectrograma gerado por um modelo de machine learning em uma forma de onda?


<Question
	choices={[
		{
			text: "Podemos usar uma rede neural chamada vocoder para reconstruir uma forma de onda a partir do espectrograma.",
			explain: "Como a informação de fase está ausente neste caso, precisamos usar um vocoder, ou o clássico algoritmo Griffin-Lim para reconstruir a forma de onda.",
			correct: true
		},
		{
			text: "Podemos usar a STFT inversa para converter o espectrograma gerado em uma forma de onda",
			explain: "Um espectrograma gerado está faltando informação de fase que é necessária para usar a STFT inversa."
		},
		{
			text: "Você não pode converter um espectrograma gerado por um modelo de machine learning em uma forma de onda.",
			explain: "Tente novamente!"
		}
	]}
/>


<EditOnGithub source="https://github.com/huggingface/audio-transformers-course/blob/main/chapters/pt-BR/chapter1/quiz.mdx" />

### Unidade 1. Trabalhando com dados de áudio
https://huggingface.co/learn/audio-course/pt-BR/chapter1/introduction.md

# Unidade 1. Trabalhando com dados de áudio

## O que você aprenderá nesta unidade

Todo processamento de áudio ou fala começa com um arquivo de áudio. Antes de aprofundarmos nestes tarefas de áudio, é importante entender o que esses arquivos realmente contêm e como trabalhar com eles.

Nesta unidade, você vai entender a terminologia fundamental relacionada a dados de áudio, incluindo aquelas formas de ondas, taxa de amostragem e espectrograma. Você também aprenderá a trabalhar com datasets de áudio, incluindo carregar e pré-processar, e como transmitir, de forma eficiente, grandes quantidades de datasets em tempo real (stream).

Ao final desta unidade, você terá uma compreensão sólida da terminologia essencial de dados de áudio e estará equipado com as habilidades necessárias para trabalhar datasets de áudio para várias aplicações. O conhecimento que você adquirirá nesta unidade servirá de base para entender o restante do curso.

<EditOnGithub source="https://github.com/huggingface/audio-transformers-course/blob/main/chapters/pt-BR/chapter1/introduction.mdx" />

### Aprenda mais
https://huggingface.co/learn/audio-course/pt-BR/chapter1/supplemental_reading.md

# Aprenda mais

Esta unidade cobriu muitos conceitos fundamentais relevantes para a compreensão de dados de áudio e como trabalhar com eles.
Quer aprender mais? Aqui você encontrará recursos adicionais que ajudarão a aprofundar seu entendimento dos tópicos e
melhorar sua experiência de estudos.

No vídeo a seguir (em inglês), Monty Montgomery, da xiph.org, apresenta demonstrações em tempo real de amostragem, quantização,
profundidade de bits e dither em equipamentos de áudio reais usando tanto análise digital moderna quanto equipamentos analógicos antigos, confira:

<Youtube id="cIQ9IXSUzuM"/>

Se você deseja se aprofundar no processamento de sinal digital, confira o livro gratuito ["Teoria dos Sinais Digitais"](https://brianmcfee.net/dstbook-site/content/intro.html) (em inglês)
escrito por Brian McFee, um Professor Assistente de Tecnologia Musical e Ciência de Dados na Universidade de Nova York e o principal maintainer
do pacote `librosa`.


<EditOnGithub source="https://github.com/huggingface/audio-transformers-course/blob/main/chapters/pt-BR/chapter1/supplemental_reading.mdx" />

### Carregue e explore um dataset de áudio
https://huggingface.co/learn/audio-course/pt-BR/chapter1/load_and_explore.md

# Carregue e explore um dataset de áudio

Neste curso, utilizaremos a biblioteca 🤗 Datasets (Hugging Face Datasets) para trabalhar com datasets de áudio. 🤗 Datasets é uma biblioteca open source para baixar e preparar datasets de todas as modalidades, incluindo áudio. A biblioteca oferece fácil acesso a uma seleção única de datasets de machine learning disponíveis publicamente no Hugging Face Hub. Além disso, 🤗 Datasets inclui várias funcionalidades adaptadas para datasets de áudio que simplificam o trabalho tanto para pesquisadores quanto para praticantes.

Para começar a trabalhar com datasets de áudio certifique-se de ter a biblioteca 🤗 Datasets instalada:

```bash
pip install datasets[audio]
```

Uma das principais características da 🤗 Datasets é a capacidade de baixar e preparar um dataset com apenas uma linha de código Python usando a função `load_dataset()`.

Vamos carregar e explorar um dataset de áudio chamado [MINDS-14](https://huggingface.co/datasets/PolyAI/minds14), que contém gravações de pessoas fazendo perguntas a um sistema de e-banking em vários idiomas e dialetos.

Para carregar o dataset MINDS-14, precisamos copiar o identificador do dataset no Hub (`PolyAI/minds14`) e passá-lo para a função `load_dataset`. Também especificaremos que estamos interessados apenas no subconjunto Australiano dos dados, e limitá-lo ao traning split (a parte dos dados somente para treino):

```py
from datasets import load_dataset

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

**Saída:**
```out
Dataset(
    {
        features: [
            "path",
            "audio",
            "transcription",
            "english_transcription",
            "intent_class",
            "lang_id",
        ],
        num_rows: 654,
    }
)
```

O dataset contém 654 arquivos de áudio, cada um possui os seguintes campos (features): transcrição, uma tradução para o inglês e um rótulo indicando o motivo da pergunta da pessoa. A coluna audio contém os dados brutos do áudio (sem processamento). Vamos dar uma olhada mais de perto em um dos exemplos:

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

**Saída:**
```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,
}
```

Note que a coluna audio contém várias features (campos ou características). Aqui está uma descrição delas:
* `path`: o caminho para o arquivo de áudio (`*.wav` neste caso).
* `array`: Os dados de áudio decodificados, representados como um array unidimensional NumPy.
* `sampling_rate`: A taxa de amostragem do arquivo de áudio (8.000 Hz neste exemplo).

O `intent_class` é uma categoria para classificar a gravação de áudio. Para converter este número em algo mais significativo, podemos usar o método `int2str()`:

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

**Saída:**
```out
"pay_bill"
```

Se você olhar o campo transcription (em inglês), vai ver que o arquivo de áudio de fato gravou uma pessoa fazendo uma pergunta sobre o pagamento de uma conta.

Se você planeja treinar um classificador de áudio com este subconjunto dos dados, você não vai precisar, necessariamente, de todos os campos. Por exemplo, o `lang_id` vai ter o mesmo valor para todos os exemplos, e não tem utilidade. A coluna `english_transcription` provavelmente será uma cópia de `transcription` neste subconjunto, então podemos removê-las tranquilamente.

Você pode facilmente remover campos (features) irrelevantes usando o método `remove_columns` da 🤗 Datasets:

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

**Saída:**
```out
Dataset({features: ["path", "audio", "transcription", "intent_class"], num_rows: 654})
```

Agora que carregamos e inspecionamos o conteúdo bruto do dataset, vamos ouvir alguns exemplos! Usaremos as propriedades `Blocks` e `Audio` do `Gradio` para decodificar algumas amostras aleatórias:

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

Se você quiser, também pode visualizar alguns dos exemplos. Vamos plotar a forma de onda para o primeiro exemplo.

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

<div class="flex justify-center">
    <img src="https://huggingface.co/datasets/huggingface-course/audio-course-images/resolve/main/waveform_unit1.png" alt="Plot da forma de onda">
</div>

Sua vez de tentar! Baixe outro dialeto ou idioma do dataset MINDS-14, ouça e visualize alguns exemplos para ter uma noção da variedade do dataset inteiro. Você pode encontrar a lista completa de idiomas disponíveis [aqui](https://huggingface.co/datasets/PolyAI/minds14).


<EditOnGithub source="https://github.com/huggingface/audio-transformers-course/blob/main/chapters/pt-BR/chapter1/load_and_explore.mdx" />

### Streaming de dados de áudio
https://huggingface.co/learn/audio-course/pt-BR/chapter1/streaming.md

# Streaming de dados de áudio

Um dos maiores desafios enfrentados com datasets de áudio é o seu tamanho imenso. Um único minuto de áudio de qualidade de CD não comprimido (44,1kHz, 16-bit) ocupa um pouco mais de 5 MB de armazenamento. Normalmente, um dataset de áudio contém horas de gravações.

Nas seções anteriores, usamos um subconjunto muito pequeno do dataset de áudio MINDS-14, no entanto, datasets de áudio típicos são muito maiores. Por exemplo, a configuração `xs` (a menor) do [GigaSpeech do SpeechColab](https://huggingface.co/datasets/speechcolab/gigaspeech) contém apenas 10 horas de dados de treinamento, mas ocupa mais de 13GB de espaço de armazenamento para download e preparação. Então, o que acontece quando queremos treinar em um conjunto maior? A configuração completa `xl` do mesmo dataset contém 10.000 horas de dados de treinamento, exigindo mais de 1TB de espaço de armazenamento. Para a maioria de nós, isso excede em muito as especificações de um disco comum. Precisamos gastar e comprar armazenamento adicional? Ou existe uma maneira de treinarmos nesses datasets sem restrições de espaço em disco?

🤗 Datasets nos salva oferecendo o [modo de streaming](https://huggingface.co/docs/datasets/stream). O Streaming nos permite carregar os dados progressivamente à medida que iteramos sobre o dataset. Em vez de baixar o dataset inteiro de uma vez, carregamos um exemplo de cada vez. Iteramos sobre o dataset, carregando e preparando exemplos na hora quando são necessários. Desta forma, só carregamos os exemplos que estamos usando, e não os que não estamos! Uma vez que terminamos com uma amostra de exemplo, continuamos iterando sobre o dataset e carregamos o próximo.

O modo de streaming tem três vantagens principais sobre o download do dataset inteiro de uma vez:

* Espaço em disco: os exemplos são carregados na memória um por um à medida que iteramos sobre o dataset. Como os dados não são baixados localmente, não há requisitos de espaço em disco, então você pode usar datasets de tamanho arbitrário.
* Tempo de download e processamento: datasets de áudio são grandes e precisam de uma quantidade significativa de tempo para serem baixados e processados. Com streaming, o carregamento e processamento é feito na hora, o que significa que você pode começar a usar o dataset assim que o primeiro exemplo estiver pronto.
* Experimentação fácil: você pode experimentar em um punhado de exemplos para verificar se o seu script funciona sem ter que baixar o dataset inteiro.

Há uma ressalva para o modo de streaming. Ao baixar um dataset completo sem streaming, tanto os dados brutos quanto os dados processados são salvos localmente no disco. Se quisermos reutilizar este dataset, podemos carregar diretamente os dados processados do disco, pulando as etapas de download e processamento. Consequentemente, só temos que realizar as operações de download e processamento uma vez, após o que podemos reutilizar os dados preparados.

Com o modo de streaming, os dados não são baixados para o disco. Assim, nem os dados baixados nem os pré-processados são armazenados em cache. Se quisermos reutilizar o dataset, as etapas de streaming devem ser repetidas, com os arquivos de áudio carregados e processados na hora novamente. Por essa razão, é aconselhável baixar datasets que você provavelmente usará várias vezes.

Como você pode habilitar o modo de streaming? Fácil! Basta definir `streaming=True` quando você carregar seu dataset. O resto será cuidado para você:

```py
gigaspeech = load_dataset("speechcolab/gigaspeech", "xs", streaming=True)
```

Assim como aplicamos etapas de pré-processamento a um subconjunto baixado do MINDS-14, você pode fazer o mesmo pré-processamento com um dataset em streaming exatamente da mesma maneira.

A única diferença é que você não pode mais acessar amostras individuais usando indexação do Python (ou seja, `gigaspeech["train"][sample_idx]`). Em vez disso, você tem que iterar sobre o dataset. Aqui está como você pode acessar um exemplo ao transmitir um dataset:

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

**Saída:**
```out
{
    "segment_id": "YOU0000000315_S0000660",
    "speaker": "N/A",
    "text": "AS THEY'RE LEAVING <COMMA> CAN KASH PULL ZAHRA ASIDE REALLY QUICKLY <QUESTIONMARK>",
    "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",
}
```

Se você gostaria de visualizar vários exemplos de um grande dataset, use o `take()` para obter os primeiros n elementos. Vamos pegar os dois primeiros exemplos no dataset gigaspeech:

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

**Saída:**
```out
[
    {
        "segment_id": "YOU0000000315_S0000660",
        "speaker": "N/A",
        "text": "AS THEY'RE LEAVING <COMMA> CAN KASH PULL ZAHRA ASIDE REALLY QUICKLY <QUESTIONMARK>",
        "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 <PERIOD>",
        "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",
    },
]
```

O modo de streaming pode levar sua pesquisa para o próximo nível: não apenas os maiores datasets estão acessíveis para você, mas você pode facilmente avaliar sistemas através de vários datasets de uma só vez sem se preocupar com o espaço em disco. Comparado à avaliação em um único dataset, a avaliação em vários datasets fornece uma métrica melhor para as habilidades de generalização de um sistema de reconhecimento de fala (c.f. End-to-end Speech Benchmark (ESB)).


<EditOnGithub source="https://github.com/huggingface/audio-transformers-course/blob/main/chapters/pt-BR/chapter1/streaming.mdx" />

### Pré-processamento de um dataset de áudio
https://huggingface.co/learn/audio-course/pt-BR/chapter1/preprocessing.md

# Pré-processamento de um dataset de áudio

Carregar um dataset com 🤗 Datasets é parte da brincadeira. Se você planeja usá-lo para treinar um modelo, ou para executar inferência, você precisará pré-processar os dados primeiro. Geralmente, isso se resume nas seguintes etapas:

* Reamostragem (resampling) dos dados de áudio
* Filtragem do dataset
* Conversão dos dados de áudio para a formato esperado pelo modelo

## Reamostragem dos dados de áudio

A função `load_dataset` baixa exemplos de áudio com a taxa de amostragem na qual foram publicados. Esta não é sempre a taxa de amostragem esperada por um modelo que você planeja treinar, ou usar para inferência. Se houver uma diferença entre as taxas de amostragem, você pode reamostrar (resample) o áudio para a taxa de amostragem esperada pelo modelo.

A maioria dos modelos pré-treinados disponíveis foram treinados em datasets de áudio com uma taxa de amostragem de 16 kHz. Quando exploramos o dataset MINDS-14, você pode ter notado que ele é amostrado a 8 kHz, o que significa que provavelmente precisaremos aumentar a amostragem.

Para fazer isso, use o método `cast_column` de 🤗 Datasets. Esta operação não altera o arquivo de áudio baixado, mas indica aos datasets para reamostrar os exemplos de áudio sob demanda a medida que forem carregados. O seguinte código definirá a taxa de amostragem para 16kHz:

```py
from datasets import Audio

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

Recarregue o primeiro exemplo de áudio no dataset MINDS-14, e verifique se ele foi reamostrado para a `taxa de amostragem` desejada:

```py
minds[0]
```

**Saída:**
```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,
}
```

Repare que os valores do array também estão diferentes agora. Isso ocorre porque agora temos o dobro do número de valores de amplitude para cada um que tínhamos antes.

<Tip>
💡 Algumas informações sobre a reamostragem (resampling): Se um sinal de áudio foi amostrado a 8 kHz, de modo que possui 8000 amostras coletadas por segundo, sabemos que o áudio não contém frequências acima de 4 kHz. Isso é garantido pelo teorema de Nyquist. Com base nisso, podemos assumir que entre as amostras de um sinal contínuo, especificamente os pontos que existem entre elas, e não foram coletados, devido a amostragem, formam uma curva suave. Então, aumentar a taxa de amostragem para um valor mais alto é apenas uma questão de calcular valores de amostra adicionais que vão entre os existentes, formando essa curva suave. No entanto, diminuir a amostragem (downsampling) requer primeiro filtrar quaisquer frequências que seriam maiores que o novo limite de Nyquist, antes de estimar os novos pontos de amostra (pois diminuindo a amostragem, a frequência máxima também diminuiria). Em outras palavras, você não pode diminuir a amostragem por um fator de 2x simplesmente descartando todas as outras amostras - isso criará distorções no sinal chamadas de alias. Fazer a reamostragem corretamente é complicado e é melhor deixar para bibliotecas bem testadas como librosa ou 🤗 Datasets.
</Tip>

## Filtragem do dataset

Talvez você precise filtrar os dados com base em alguns critérios. Um dos casos comuns envolve limitar os exemplos de áudio a uma certa duração. Por exemplo, podemos querer ignorar quaisquer exemplos mais longos que 20s para prevenir erros de falta de memória ao treinar um modelo.

Podemos fazer isso usando o método `filter` da 🤗 Datasets e passando uma função com a lógica de filtragem para ele. Vamos começar escrevendo uma função que indica quais exemplos manter e quais descartar. Esta função, `is_audio_length_in_range`, retorna `True` se a duração for menor 20s, e `False` se for maior.

```py
MAX_DURATION_IN_SECONDS = 20.0


def is_audio_length_in_range(input_length):
    return input_length < MAX_DURATION_IN_SECONDS
```

A função de filtragem pode ser aplicada a uma coluna do dataset, mas não temos uma coluna com a duração da do áudio neste dataset. No entanto, podemos criar uma, filtrar com base nos valores dessa coluna e, em seguida, removê-la.

```py
# use librosa para obter a duração do áudio
new_column = [librosa.get_duration(path=x) for x in minds["path"]]
minds = minds.add_column("duration", new_column)

# use o método `filter` de 🤗 Datasets para aplicar a função de filtragem
minds = minds.filter(is_audio_length_in_range, input_columns=["duration"])

# remova a coluna auxiliar temporária
minds = minds.remove_columns(["duration"])
minds
```

**Saída:**
```out
Dataset({features: ["path", "audio", "transcription", "intent_class"], num_rows: 624})
```

Perceba que o dataset foi filtrado de 654 exemplos para 624 (num_rows).

## Pré-processamento dos dados de áudio

Um dos aspectos mais desafiadores de trabalhar com datasets de áudio é preparar os dados no formato correto para o treinamento do modelo. Como você viu, os dados de áudio brutos vêm como um array de valores de amostras (do sinal original). No entanto, modelos pré-treinados, seja para usá-los em inferência, seja para ajustá-los (fine tuning) ao seu projeto, esperam que os dados brutos sejam convertidos em características (features) de entrada. Os requisitos para as características de entrada podem variar de um modelo para outro - eles dependem da arquitetura do modelo e dos dados com os quais foi pré-treinado. A boa notícia é que, para cada modelo de áudio suportado, 🤗 Transformers oferece uma classe de extrator de características (feature extractor) que pode converter dados de áudio brutos nas características de entrada que o modelo espera.

Então, o que um extrator de características faz com os dados de áudio brutos? Vamos dar uma olhada extrator de características chamado [Whisper](https://huggingface.co/papers/2212.04356) para entender algumas transformações comuns de extração de características. Whisper é um modelo pré-treinado para reconhecimento automático de fala (ASR) publicado em setembro de 2022 por Alec Radford et al. da OpenAI.

Primeiro, o extrator de características do Whisper preenche/corta um grupo (batch) de exemplos de áudio de forma que todos os exemplos tenham uma duração de 30s. Exemplos mais curtos que isso são complementados com zeros no final, até formar 30s de duração (zeros em um sinal de áudio correspondem a silêncio ou nada de sinal). Exemplos que tem mais de 30s são cortados nos 30s. Uma vez que todos os elementos no grupo são padronizados para uma duração fixa, não há necessidade de uma máscara de atenção (attention mask). O Whisper é único neste aspecto, a maioria dos outros modelos de áudio requer uma máscara de atenção que detalha onde as sequências foram preenchidas, e assim onde elas devem ser ignoradas no mecanismo de auto-atenção (self-attention). O Whisper é treinado para operar sem uma máscara de atenção e inferir do próprio sinal onde ele deve ignorar.

A segunda operação que o extrator de características do Whisper realiza é converter os arrays de áudio padronizados em espectrogramas log-mel. Lembre que esses espectrogramas descrevem como as frequências de um sinal mudam ao longo do tempo, expressas na escala mel e medidas em decibéis (a parte do log) para tornar as frequências e amplitudes mais representativas da audição humana.

Todas essas transformações podem ser aplicadas aos seus dados de áudio brutos com algumas poucas linhas de código. Vamos colocar a mão na massa e carregar o extrator de características a partir do checkpoint pré-treinado do Whisper e deixá-lo pronto para usar nos nossos dados de áudio:

```py
# Instale com o comando: pip install transformers
# Você pode acessar a página incial dos Transformers para instruções de instalação!
from transformers import WhisperFeatureExtractor

feature_extractor = WhisperFeatureExtractor.from_pretrained("openai/whisper-small")
```

Então, você pode escrever uma função para pré-processar um exemplo de áudio, passando ele para o `feature_extractor`.

```py
def prepare_dataset(example):
    audio = example["audio"]
    features = feature_extractor(
        audio["array"], sampling_rate=audio["sampling_rate"], padding=True
    )
    return features
```

Podemos aplicar a função de preparação de dados a todos os nossos exemplos de treinamento usando o método `map` de 🤗 Datasets:

```py
minds = minds.map(prepare_dataset)
minds
```

**Saída:**
```out
Dataset(
    {
        features: ["path", "audio", "transcription", "intent_class", "input_features"],
        num_rows: 624,
    }
)
```
Sem muito esforço, agora temos espectrogramas log-mel no campo `input_features` do dataset.

Vamos visualizá-lo em dos exemplos do dataset `minds`:

```py
import numpy as np

example = minds[0]
input_features = example["input_features"]

plt.figure().set_figwidth(12)
librosa.display.specshow(
    np.asarray(input_features[0]),
    x_axis="time",
    y_axis="mel",
    sr=feature_extractor.sampling_rate,
    hop_length=feature_extractor.hop_length,
)
plt.colorbar()
```

<div class="flex justify-center">
    <img src="https://huggingface.co/datasets/huggingface-course/audio-course-images/resolve/main/log_mel_whisper.png" alt="Gráfico de espectrograma log mel">
</div>

Agora você pode ver como fica um input de áudio para o modelo Whisper após o pré-processamento.

A classe de extrator de características do modelo cuida de transformar os dados de áudio brutos para o formato que o modelo espera. No entanto, muitas tarefas envolvendo áudio são multimodais, como, por exemplo, o reconhecimento de fala. Nestes casos, 🤗 Transformers também oferece tokenizadores (tokenizers) específicos do modelo para processar as entradas de texto. Para se aprofundar em tokenizadores, consulte nosso [curso de NLP](https://huggingface.co/course/chapter2/4).

Você pode carregar o extrator de características e o tokenizador do Whisper (e outros modelos multimodais) separadamente, ou você pode carregar ambos por meio de algo chamado de processor (processador). Para simplificar ainda mais, use `AutoProcessor` para carregar o extrator de características e processador de um modelo a partir de um checkpoint, assim:

```py
from transformers import AutoProcessor

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

Aqui mostramos os passos fundamentais de preparação dos dados. Claro, dados personalizados podem exigir pré-processamento mais complexo. Neste caso, você pode estender a função `prepare_dataset` para realizar qualquer tipo de transformação de dados personalizada. Com 🤗 Datasets, se você pode escrever sua personalização como uma função Python, então você pode [aplicá-la](https://huggingface.co/docs/datasets/audio_process) ao seu dataset!


<EditOnGithub source="https://github.com/huggingface/audio-transformers-course/blob/main/chapters/pt-BR/chapter1/preprocessing.mdx" />

### Introdução a dados de áudio
https://huggingface.co/learn/audio-course/pt-BR/chapter1/audio_data.md

# Introdução a dados de áudio

Por natureza, uma onda sonora é um sinal contínuo, o que significa que contém um número infinito de valores de sinal em um determinado tempo. Isso traz problemas para dispositivos digitais que esperam arrays finitos. Para ser processada, armazenada e transmitida por dispositivos digitais, a onda sonora contínua precisa ser convertida em uma série de valores discretos, conhecidos como representação digital.

Se você olhar para qualquer dataset de áudio, encontrará arquivos digitais com trechos de som, como narração de texto ou música. Você pode encontrar diferentes formatos de arquivo, como `.wav` (Waveform Audio File), `.flac` (Free Lossless Audio Codec) e `.mp3` (MPEG-1 Audio Layer 3). Esses formatos diferem principalmente na forma como comprimem a representação digital do sinal de áudio.

Vamos dar uma olhada em como saímos de um sinal contínuo para essa representação. O sinal analógico é primeiro capturado por um microfone, que converte as ondas sonoras em um sinal elétrico. O sinal elétrico é então digitalizado por um Conversor Analógico-Digital para obter a representação digital por meio da amostragem.

## Amostragem e taxa de amostragem

Amostragem (sampling) é o processo de medir o valor de um sinal contínuo em etapas (amostras) que possuem o mesmo tempo. A forma da onda que foi amostrada é _discreta_, pois contém um número finito dos valores do sinal em intervalos uniformes.

<div class="flex justify-center">
    <img src="https://huggingface.co/datasets/huggingface-course/audio-course-images/resolve/main/Signal_Sampling.png" alt="Ilustração de amostragem de sinal">
</div>

*Ilustração deste artigo da Wikipedia: [Amostragem (processamento de sinal)](https://en.wikipedia.org/wiki/Sampling_(signal_processing))*

A **taxa de amostragem** (também chamada de frequência de amostragem, sampling rate ou sampling frequency) é o número de amostras feitas em um segundo e é medida em hertz (Hz). Para você ter ideia, áudio com qualidade de CD tem uma taxa de amostragem de 44.100 Hz, o que significa que as amostras são feitas 44.100 vezes por segundo. Para comparação, o áudio de alta resolução tem uma taxa de amostragem de 192.000 Hz ou 192 kHz. Uma taxa de amostragem comum usada no treinamento de modelos de fala é de 16.000 Hz ou 16 kHz.

A escolha da taxa de amostragem determina, principalmente, a maior frequência que pode ser capturada do sinal. Isso também é conhecido como o limite de Nyquist e é exatamente a metade da taxa de amostragem. As frequências audíveis na fala humana estão abaixo de 8 kHz e, portanto, amostrar a fala a 16 kHz é suficiente. Usar uma taxa de amostragem mais alta não capturará mais informações e apenas leva a um aumento no custo computacional de processar tais arquivos. Por outro lado, amostrar áudio em uma taxa de amostragem muito baixa resultará em perda de informação. A fala amostrada a 8 kHz soará abafada, pois as frequências mais altas não podem ser capturadas nessa taxa.

É importante garantir que todos os exemplos de áudio no seu dataset tenham a mesma taxa de amostragem ao trabalhar em qualquer processamento de áudio. Se você planeja usar dados de áudio personalizados para ajustar um modelo pré-treinado, a taxa de amostragem dos seus dados deve corresponder à taxa de amostragem dos dados em que o modelo foi pré-treinado. A taxa de amostragem determina o intervalo de tempo entre amostras de áudio sucessivas, o que impacta a resolução temporal dos dados de áudio. Considere um exemplo: um som de 5 segundos a uma taxa de amostragem de 16.000 Hz será representado como uma série de 80.000 valores (16.000 x 5), enquanto o mesmo som de 5 segundos a uma taxa de amostragem de 8.000 Hz será representado como uma série de 40.000 valores. Modelos Transformers que resolvem tarefas de áudio tratam exemplos como sequências e dependem de mecanismos de atenção para aprender áudio ou representações multimodais. Como as sequências são diferentes para exemplos de áudio em diferentes taxas de amostragem, será desafiador para os modelos generalizarem entre taxas de amostragem. **Reamostragem** (Resampling) é o processo de fazer as taxas de amostragem se igualarem, e faz parte do [pré-processamento](preprocessing#resampling-the-audio-data) dos dados de áudio.

## Amplitude e profundidade de bits (bit depth)

Enquanto a taxa de amostragem diz com que frequência as amostras são feitas, o que exatamente são os valores em cada amostra?

O som é feito por mudanças na pressão do ar em frequências audíveis para humanos. A **amplitude** de um som descreve o nível de pressão sonora em um dado momento e é medida em decibéis (dB). Percebemos a amplitude como volume. Para lhe dar um exemplo, uma voz falando normalmente está abaixo de 60 dB, e um show de rock pode estar em torno de 125 dB, forçando os limites da audição humana.

No áudio digital, cada amostra do áudio é o valor da amplitude da onda sonora em um ponto no tempo. A **profundidade de bits** (bit depth) da amostra determina o quão preciso esse valor pode ser. Quanto maior a profundidade de bits, mais fiel será a representação digital da onda sonora contínua original.

As profundidades de bit de áudio mais comuns são 16 bits e 24 bits. Cada uma representa o número máximo de valores distintos que podem ser registrados em cada amostra: 65.536 valores para áudio de 16 bits, impressionantes 16.777.216 valores para áudio de 24 bits. Devido ao fato que essa quantização do valor contínuo para o discreto envolve arredondamento, o processo de amostragem causa ruído. Quanto maior a profundidade de bits, menor esse ruído de quantização. Na prática, o ruído de quantização do áudio de 16 bits já é pequeno o suficiente para ser inaudível, e usar profundidades de bits maiores geralmente não é necessário.

Você também pode encontrar áudio de 32 bits. Isso armazena as amostras como valores de ponto flutuante (decimal), enquanto o áudio de 16 bits e 24 bits usa amostras inteiras. A precisão de um valor de ponto flutuante de 32 bits é de 24 bits, dando-lhe a mesma profundidade de bits que o áudio de 24 bits. Amostras de áudio de ponto flutuante são esperadas para estar dentro do intervalo [-1.0, 1.0]. Como os modelos de machine learning trabalham naturalmente com dados de ponto flutuante, o áudio deve primeiro ser convertido para o formato de ponto flutuante antes de poder ser usado para treinar o modelo. Veremos como fazer isso na próxima seção sobre [Pré-processamento](preprocessing).

Assim como com sinais de áudio contínuos, a amplitude do áudio digital é tipicamente expressa em decibéis (dB). Como a audição humana é logarítmica por natureza — nossos ouvidos são mais sensíveis a pequenas flutuações em sons silenciosos do que em sons altos — a intensidade de um som é mais fácil de interpretar se as amplitudes estiverem em decibéis, que também são logarítmicos. A escala de decibéis para áudio do mundo real começa em 0 dB, que representa o som mais baixo possível que os humanos podem ouvir, e sons mais altos têm valores maiores. No entanto, para sinais de áudio digitais, 0 dB é a amplitude mais alta possível, enquanto todas as outras amplitudes são negativas. Como uma regra rápida: a cada -6 dB é uma redução pela metade da amplitude, e qualquer coisa abaixo de -60 dB geralmente é inaudível a menos que você realmente aumente o volume.

## Áudio como uma forma de onda

Você já pode ter visto sons visualizados como uma **forma de onda**, que traça os valores das amostras ao longo do tempo e ilustra as mudanças na amplitude do som. Isso também é conhecido como a representação do *domínio do tempo* do som.

Esse tipo de visualização é útil para identificar características específicas do sinal de áudio, como o momento de eventos sonoros individuais, o volume geral do sinal e quaisquer irregularidades ou ruídos presentes no áudio.

Para traçar a forma de onda de um sinal de áudio, podemos usar uma biblioteca Python chamada `librosa`:

```bash
pip install librosa
```

Vamos pegar um exemplo de som chamado "trompete" que vem com a biblioteca:

```py
import librosa

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

O exemplo é carregado como uma tupla contendo uma sequencia temporal de áudio (aqui chamamos de `array`) e a taxa de amostragem (`sampling_rate`). Vamos dar uma olhada na forma de onda deste som usando a função `waveshow()` da librosa:

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

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

<div class="flex justify-center">
    <img src="https://huggingface.co/datasets/huggingface-course/audio-course-images/resolve/main/waveform_plot.png" alt="Forma de onda">
</div>

Isso coloca a amplitude do sinal no eixo y e o tempo ao longo do eixo x. Em outras palavras, cada ponto corresponde a um único valor de amostra que foi feito quando este som foi amostrado. Também observe que a librosa já retorna o áudio como valores de ponto flutuante e que os valores de amplitude estão de fato dentro do intervalo [-1,0, 1,0].

Visualizar o áudio junto com ouvi-lo pode ser uma ferramenta útil para entender os dados com os quais você está trabalhando. Você pode ver a forma do sinal, observar padrões, aprender a identificar ruídos ou distorção. Se você pré-processar dados de alguma forma, como normalização, reamostragem ou filtragem, você pode confirmar visualmente que as etapas de pré-processamento foram aplicadas conforme esperado. Após treinar um modelo, você também pode visualizar amostras onde ocorrem erros (por exemplo, em tarefa de classificação de áudio) para fazer o debug do problema.

## O espectro de frequência

Outra maneira de visualizar dados de áudio é plotar o **espectro de frequência** de um sinal de áudio, também conhecido como a representação do *domínio da frequência*. O espectro é calculado usando a transformada de Fourier discreta ou DFT. Ele descreve as frequências individuais que compõem o sinal e quão fortes elas são.

Vamos plotar o espectro de frequência para o mesmo som de trompete, fazendo a DFT usando a função `rfft()` do numpy. Embora seja possível plotar o espectro de todo o som, é mais útil olhar para uma pequena região em vez disso. Aqui vamos fazer a DFT sobre as primeiras 4096 amostras, que é aproximadamente o comprimento da primeira nota sendo tocada:

```py
import numpy as np

dft_input = array[:4096]

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

# obtém as amplitude do espectro, em decibeis
amplitude = np.abs(dft)
amplitude_db = librosa.amplitude_to_db(amplitude, ref=np.max)

# obtém a frquency bins (faixas de frequencia)
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")
```

<div class="flex justify-center">
    <img src="https://huggingface.co/datasets/huggingface-course/audio-course-images/resolve/main/spectrum_plot.png" alt="Spectrum plot">
</div>

Isso mostra um gráfico com a força de várias frequências que estão presentes neste trecho de áudio. Os valores da frequência estão no eixo x, geralmente plotados em uma escala logarítmica, enquanto suas amplitudes estão no eixo y.

O espectro de frequência que plotamos mostra vários picos. Esses picos correspondem aos harmônicos da nota que está sendo tocada, com os harmônicos superiores sendo mais silenciosos. Como o primeiro pico está em torno de 620 Hz, este é o espectro de frequência de uma nota E♭ (Mi bemol).

O resultado da DFT é um array de números complexos, compostos de componentes reais e imaginários. Obtendo a magnitude (valor absoluto, sem sinal) com `np.abs(dft)`, extraímos as informação de amplitude do espectrograma. O ângulo entre os componentes reais e imaginários fornece o chamado espectro de fase, mas isso é frequentemente descartado em aplicações de machine learning.

Você usou `librosa.amplitude_to_db()` para converter os valores de amplitude para a escala de decibéis, facilitando a visualização dos mínimos detalhes no espectro. Às vezes, as pessoas usam o **espectro de potência**, que mede a energia em vez da amplitude; isso é simplesmente um espectro com os valores de amplitude ao quadrado.

<Tip>
💡 Na prática, as pessoas usam o termo FFT e DFT como sinônimos, já que a FFT, ou Fast Fouriter Transform (Transformada Rápida de Fourier), é a única maneira eficiente de calcular a DFT em um computador.
</Tip>

O espectro de frequência de um sinal de áudio contém exatamente as mesmas informações que sua forma de onda — são simplesmente duas maneiras diferentes de olhar para os mesmos dados (no caso, as primeiras 4096 amostras do som de trompete). Enquanto a forma de onda traça a amplitude do sinal de áudio ao longo do tempo, o espectro visualiza as amplitudes de cada frequência em um ponto fixo no tempo.

## Espectrograma

E se quisermos ver como as frequências em um sinal de áudio mudam? O trompete toca várias notas e todas elas têm frequências diferentes. O problema é que o espectro mostra apenas "uma foto" das frequências em um dado instante. A solução é fazer várias DFTs, cada uma cobrindo apenas uma pequena fatia de tempo, e empilhar os espectros resultantes formando um **espectrograma**.

Um espectrograma mostra o conteúdo da frequência de um sinal de áudio à ao longo do tempo. Ele permite que você veja tempo, frequência e amplitude tudo em um único gráfico. O algoritmo que realiza esse cálculo é o STFT (Short Time Fourier Transform) ou Transformada de Fourier de Tempo Curto.

O espectrograma é uma das ferramentas de áudio mais informativas disponíveis para você. Por exemplo, ao trabalhar com uma gravação de música, você pode ver os vários instrumentos e faixas vocais e como eles contribuem para o som geral. Na fala, você pode identificar diferentes sons de vogais, pois cada vogal é caracterizada por frequências particulares.

Vamos plotar um espectrograma para o mesmo som de trompete, usando as funções `stft()` e `specshow()` da librosa:

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

<div class="flex justify-center">
    <img src="https://huggingface.co/datasets/huggingface-course/audio-course-images/resolve/main/spectrogram_plot.png" alt="Spectrogram plot">
</div>

Neste gráfico, o eixo x representa o tempo como na visualização da forma de onda, mas agora o eixo y representa a frequência em Hz. A intensidade da cor dá a amplitude ou potência do componente de frequência em cada ponto no tempo, medida em decibéis (dB).

O espectrograma é criado obtendo trechos curtos do sinal de áudio, geralmente durando alguns milissegundos, e calculando a transformada de Fourier discreta de cada trecho para obter seu espectro de frequência. Os espectros resultantes são colocados em sequência eixo do tempo para criar o espectrograma. Cada fatia vertical nesta imagem corresponde a um único espectro de frequência, como se o gráfico fosse girado. Por padrão, `librosa.stft()` divide o sinal de áudio em trechos de 2048 amostras, o que dá um bom equilíbrio entre resolução de frequência e resolução de tempo.

Como o espectrograma e a forma de onda são visualizações diferentes dos mesmos dados, é possível transformar o espectrograma de volta na forma de onda original usando a STFT inversa. No entanto, isso requer a informação de fase, além da amplitude. Se o espectograma foi gerado por um modelo de machine learning, geralmente ele contém só as amplitudes. Neste caso, nós podemos usar um algoritmo de reconstrução de fase como o clássico algoritmo de Griffin-Lim ou usar uma rede neural chamada vocoder, que reconstroi a forma de onda partir do espectograma.

Os espectrogramas não são usados apenas para visualização. Muitos modelos de machine learning utilizam espectrogramas como entrada — ao invés de formas de onda — e produzem espectrogramas como saída.

Agora que sabemos o que é um espectrograma e como é feito, vamos dar uma olhada em uma variante dele amplamente usada para o processamento de fala: o espectrograma mel.

## Espectrograma Mel

Um espectrograma mel é uma variação do espectrograma que é comumente usada no processamento de fala e tarefas de machine learning.
É semelhante a um espectrograma no sentido de que mostra o conteúdo de frequência de um sinal de áudio ao longo do tempo, mas em um eixo de frequência diferente.

Em um espectrograma padrão, o eixo de frequência é linear e é medido em hertz (Hz). No entanto, o sistema auditivo humano
é mais sensível a mudanças em frequências mais baixas do que em frequências mais altas, e essa sensibilidade diminui logaritmicamente
à medida que a frequência aumenta. A escala mel é uma escala perceptual que aproxima a resposta de frequência não linear do ouvido humano.

Para criar um espectrograma mel, a STFT é usada como antes, dividindo o áudio em segmentos curtos para obter uma sequência
de espectros de frequência. Além disso, cada espectro é enviado através de um conjunto de filtros, o chamado banco de filtros mel, para
transformar as frequências para a escala mel.

Vamos ver como podemos plotar um espectrograma mel usando a função `melspectrogram()` da librosa, que realiza todos esses passos para nós:

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

<div class="flex justify-center">
    <img src="https://huggingface.co/datasets/huggingface-course/audio-course-images/resolve/main/mel-spectrogram.png" alt="Gráfico de espectrograma mel">
</div>


No exemplo acima, `n_mels` indica o número de bandas mel a serem geradas. As bandas mel definem um conjunto de
faixas de frequência que dividem o espectro em componentes perceptualmente significativos, usando um conjunto de filtros cuja forma e espaçamento
são escolhidos para imitar a forma como o ouvido humano responde a diferentes frequências. Valores comuns para `n_mels` são 40 ou 80. `fmax`
indica a frequência mais alta (em Hz) com a qual nos preocupamos.

Assim como com um espectrograma regular, é prática comum expressar a intesidade de cada frequência mel em
decibéis. Isso é comumente referido como um **espectrograma log-mel**, porque a conversão para decibéis envolve uma
operação logarítmica. O exemplo acima usou `librosa.power_to_db()` já que `librosa.feature.melspectrogram()` cria um espectrograma de potência.

<Tip>
💡 Nem todos os espectrogramas mel são iguais! Existem duas escalas mel diferentes comumente usadas ("htk" e "slaney"),
e, ao invés do espectrograma de potência, pode ser usado o espectrograma de amplitude.

 A conversão para um espectrograma log-mel não
calcula sempre decibéis reais, mas pode simplesmente calcular `log`. Portanto, se um modelo de aprendizado de máquina espera um espectrograma mel
como entrada, certifique-se de garantir que você está calculando da mesma maneira.
</Tip>

Criar um espectrograma mel é uma operação com perda, pois envolve filtragem do sinal. Converter um espectrograma mel de volta
em uma forma de onda é mais difícil do que fazer isso para um espectrograma regular, pois exige a estimação das frequências
que foram descartadas. É por isso que modelos de aprendizado de máquina como o vocoder HiFiGAN são necessários para produzir uma forma de onda a partir de um espectrograma mel.

Comparado a um espectrograma padrão, um espectrograma mel pode capturar características mais significativas do sinal de áudio para
a percepção humana, tornando-o uma escolha popular em tarefas como reconhecimento de fala, identificação de falante e classificação de gênero musical.

Agora que você sabe como visualizar exemplos de dados de áudio, vá em frente e tente ver como seus sons favoritos parecem. :)


<EditOnGithub source="https://github.com/huggingface/audio-transformers-course/blob/main/chapters/pt-BR/chapter1/audio_data.mdx" />
