Phase 07 - Lesson 10

Transformers de Áudio — Arquitetura Whisper

This lesson includes a graded coding exercise that runs in your browser, unlocked with lifetime access.

O áudio é uma imagem de frequência ao longo do tempo. O Whisper é um ViT que consome espectrogramas mel e fala de volta.

Tipo: Aprender Linguagens: Python Pré-requisitos: Fase 7 · 05 (Full Transformer), Fase 7 · 08 (Encoder-Decoder), Fase 7 · 09 (ViT) Tempo: ~45 minutos

O Problema

Antes do Whisper (OpenAI, Radford et al. 2022), o estado da arte em reconhecimento automático de fala (ASR) significava wav2vec 2.0 e HuBERT — extratores de características auto-supervisionados combinados com um cabeçalho ajustado (fine-tuned head). Alta qualidade, pipelines de dados caros, sensíveis ao domínio. O reconhecimento de fala multilíngue exigia modelos separados por família de línguas.

O Whisper fez três apostas:

1. Treinar em tudo. 680.000 horas de áudio com rotulação fraca (weakly-labeled) coletadas da internet em 97 idiomas. Sem corpus acadêmico limpo. Sem rótulos de fonemas.
2. Modelo único multitarefa. Um decodificador treinado conjuntamente em transcrição, tradução, detecção de atividade de voz, identificação de idioma e marcação de tempo (timestamping) via tokens de tarefa.
3. Transformer codificador-decodificador padrão. O codificador consome espectrogramas log-mel. O decodificador produz tokens de texto de forma autorregressiva. Sem vocoder, sem CTC, sem HMM.

O resultado: o Whisper large-v3 é robusto em diferentes sotaques, ruídos e idiomas que possuem zero dados rotulados limpos. Ele é o front-end de fala padrão para todos os assistentes de voz de código aberto e a maioria dos comerciais em 2026.

O Conceito

Passo 1 — reamostragem + janelamento

Áudio a 16 kHz. Cortar/preencher para 30 segundos. Calcular o espectrograma log-mel: 80 faixas de mel (mel bins), stride de 10 ms → ~3.000 frames × 80 características. Esta é a "imagem de entrada" que o Whisper vê.

Passo 2 — tronco convolucional

Duas camadas Conv1D com kernel 3 e stride 2 reduzem os 3.000 frames para 1.500. Isso reduz o comprimento da sequência pela metade sem adicionar muitos parâmetros.

Passo 3 — codificador

Um codificador transformer de 24 camadas (para a versão large) sobre 1.500 passos de tempo. Codificação posicional senoidal, auto-atenção, FFN com GELU. Produz 1.500 × 1.280 estados ocultos (hidden states).

Passo 4 — decodificador

Um decodificador transformer de 24 camadas. Ele produz tokens de forma autorregressiva a partir de um vocabulário BPE que é um superconjunto do vocabulário do GPT-2 com alguns tokens especiais específicos para áudio.

Passo 5 — tokens de tarefa

O prompt do decodificador começa com tokens de controle que dizem ao modelo o que fazer:

<|startoftranscript|>  <|en|>  <|transcribe|>  <|0.00|>

ou

<|startoftranscript|>  <|fr|>  <|translate|>   <|0.00|>

O modelo foi treinado sob essa convenção. Você controla a tarefa pelo prefixo. O equivalente em 2026 ao ajuste de instruções (instruction-tuning), mas aplicado à fala.

Passo 6 — saída

Busca em feixe (beam search com largura 5) com um limiar de log-probabilidade. As marcações de tempo (timestamps) são previstas a cada 0,02 segundos de áudio quando o token <|notimestamps|> está ausente.

Tamanhos do Whisper

O Large-v3-turbo (2024) reduziu o decodificador de 32 para 4 camadas. Decodificação 8× mais rápida com uma regressão de <1 ponto de WER (Word Error Rate). Essa liberação de velocidade de decodificação é o motivo pelo qual o Whisper-turbo é o padrão para agentes de voz em tempo real em 2026.

O que o Whisper não faz

• Sem diarização (identificar quem está falando). Combine com o pyannote para isso.
• Sem suporte nativo a streaming em tempo real — a janela de 30 segundos é fixa. Wrappers modernos (faster-whisper, WhisperX) adicionam streaming via VAD + sobreposição (overlap).
• Sem contexto de longo formato além de 30 s sem divisão externa em partes (chunking). Funciona bem na prática porque a fala humana raramente necessita de contexto de longo alcance para transcrição.

O cenário em 2026

Desenvolva

Consulte code/main.py. Nós não treinamos o Whisper — nós desenvolvemos o pipeline do espectrograma log-mel + formatador de prompt de tokens de tarefa. Essas são as partes com as quais você realmente interage em produção.

Passo 1: sintetizar áudio

Gerar uma onda senoidal de 1 segundo a 440 Hz amostrada a 16 kHz. 16.000 amostras.

Passo 2: espectrograma log-mel (simplificado)

O espectrograma mel completo necessita de FFT. Nós fazemos uma versão simplificada com janelamento + energia por frame que demonstra o pipeline sem exigir librosa:

def frame_signal(x, frame_size=400, hop=160):
    frames = []
    for start in range(0, len(x) - frame_size + 1, hop):
        frames.append(x[start:start + frame_size])
    return frames

Frame = 25 ms, hop = 10 ms. Corresponde ao janelamento do Whisper. A energia por frame substitui as faixas de mel (mel bins) para fins pedagógicos.

Passo 3: preencher para 30 s

O Whisper sempre processa blocos de 30 segundos. Preencha (ou corte) o espectrograma para 3.000 frames.

Passo 4: construir os tokens do prompt

def whisper_prompt(lang="en", task="transcribe", timestamps=True):
    tokens = ["<|startoftranscript|>", f"<|{lang}|>", f"<|{task}|>"]
    if not timestamps:
        tokens.append("<|notimestamps|>")
    return tokens

Essa é toda a superfície de controle de tarefas. Um prefixo de 4 tokens.

Utilize

import whisper
model = whisper.load_model("large-v3-turbo")
result = model.transcribe("meeting.wav", language="en", task="transcribe")
print(result["text"])
print(result["segments"][0]["start"], result["segments"][0]["end"])

Mais rápido, compatível com a OpenAI:

from faster_whisper import WhisperModel
model = WhisperModel("large-v3-turbo", compute_type="int8_float16")
segments, info = model.transcribe("meeting.wav", vad_filter=True)
for s in segments:
    print(f"{s.start:.2f} - {s.end:.2f}: {s.text}")

Quando escolher o Whisper em 2026:

• ASR multilíngue com um único modelo.
• Transcrição robusta de áudios ruidosos e diversos.
• Pesquisa / protótipo de ASR — o ponto de partida mais rápido.

Quando escolher outra opção:

• Streaming com latência ultrabaixa na borda (edge) — o Moonshine supera o Whisper com qualidade equivalente.
• IA conversacional em tempo real que necessita de <200 ms — ASR de streaming dedicada.
• Diarização de locutor — o Whisper não faz isso; adicione o pyannote.

Coloque em Produção

Consulte outputs/skill-asr-configurator.md. A skill escolhe um modelo de ASR, parâmetros de decodificação e pipeline de pré-processamento para uma nova aplicação de fala.

Exercícios

1. Fácil. Execute code/main.py. Confirme que a contagem de frames para um sinal de 1 segundo a 16 kHz com salto (hop) de 10 ms é de ~100 frames. Para 30 segundos: ~3.000 frames.
2. Médio. Construa o espectrograma log-mel completo usando numpy.fft. Verifique se as 80 faixas de mel correspondem a librosa.feature.melspectrogram(n_mels=80) dentro do erro numérico.
3. Difícil. Implemente a inferência por streaming: divida o áudio em janelas de 10 s com sobreposição de 2 s, execute o Whisper em cada bloco e mescle as transcrições. Meça a taxa de erro de palavras (WER) em comparação com uma única passagem em uma amostra de podcast de 5 minutos.

Termos-Chave

Leituras Adicionais

• Radford et al. (2022). Robust Speech Recognition via Large-Scale Weak Supervision — Artigo do Whisper.
• OpenAI Whisper repo — código de referência + pesos do modelo. Leia whisper/model.py para ver o tronco Conv1D + codificador + decodificador de ponta a ponta em ~400 linhas.
• OpenAI Whisper — whisper/decoding.py — a lógica de busca em feixe (beam-search) + tokens de tarefa descrita nos Passos 5-6 está aqui; 500 linhas, totalmente legível.
• Baevski et al. (2020). wav2vec 2.0: A Framework for Self-Supervised Learning of Speech Representations — precursor; ainda possui características SOTA em algumas configurações.
• SYSTRAN/faster-whisper — wrapper de produção, 4× mais rápido que a referência.
• Jia et al. (2024). Moonshine: Speech Recognition for Live Transcription and Voice Commands — ASR amigável para borda (edge) de 2024, formato similar ao Whisper, mas menor.
• HuggingFace blog — "Fine-Tune Whisper For Multilingual ASR with Transformers" — receita canônica de ajuste fino, incluindo o pré-processador de espectrograma mel e a manipulação de tokens com marcação de tempo (timestamp).
• HuggingFace modeling_whisper.py — implementação completa (codificador, decodificador, atenção cruzada, geração) que reflete o diagrama de arquitetura da lição.