Phase 06 - Lesson 03

Classificação de Áudio — De k-NN sobre MFCCs ao AST e ao BEATs

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

Tudo, desde "cachorro latindo vs. sirene" até "qual idioma é este", é classificação de áudio. As features são mels. A arquitetura muda a cada década. A avaliação continua sendo AUC, F1 e recall por classe.

Tipo: Build Linguagens: Python Pré-requisitos: Fase 6 · 02 (Espectrogramas e Mel), Fase 3 · 06 (CNNs), Fase 5 · 08 (CNNs e RNNs para Texto) Tempo: ~75 minutos

O Problema

Você recebe um clipe de 10 segundos. Você quer saber: "o que é isto?" Som urbano (sirene, furadeira, cachorro), comando de fala (sim/não/parar), identificação de idioma (en/es/ar), emoção do falante (irritado/neutro) ou som ambiente (interno/externo, burburinho). Tudo isso é classificação de áudio, e em 2026 a arquitetura de referência está madura: log-mel → CNN ou Transformer → softmax.

A dificuldade central não é a rede. São os dados. Os conjuntos de dados de áudio têm desbalanceamento brutal de classes, forte mudança de domínio (limpo vs. ruidoso) e ruído de rótulo (quem decidiu o que é "burburinho urbano" vs. "ruído de restaurante"?). Os 80% do problema estão na curadoria, na augmentação e na avaliação, não em trocar a CNN pelo Transformer.

O Conceito

k-NN sobre MFCCs (a baseline dos anos 1990). Achate os MFCCs por clipe, calcule a similaridade de cosseno em relação a um banco rotulado e retorne o voto majoritário dos K mais próximos. Surpreendentemente forte em conjuntos de dados limpos e pequenos (Speech Commands, ESC-50). Roda sem GPU.

CNN 2D sobre log-mels (2015-2019). Trate o log-mel (T, n_mels) como uma imagem. Aplique ResNet-18 ou estilo VGG. Faça global mean pool no eixo do tempo. Softmax sobre as classes. Ainda é a baseline na maioria das competições do kaggle em 2026.

Audio Spectrogram Transformer, AST (2021-2024). Divida o log-mel em patches (por exemplo, patches 16×16), adicione embeddings de posição e alimente um ViT. Estado da arte no AudioSet (mAP 0,485) para aprendizado supervisionado.

BEATs e WavLM-base (2024-2026). Pré-treinamento autossupervisionado em milhões de horas. Faça fine-tune na sua tarefa com 1-10% dos dados supervisionados que você teria precisado. Em 2026 este é o ponto de partida padrão para áudio não relacionado a fala. O BEATs-iter3 supera o AST em 1-2 mAP no AudioSet usando 1/4 do poder computacional.

Encoder do Whisper como backbone congelado (2024). Pegue o encoder do Whisper, descarte o decoder e acople um classificador linear. Próximo do SOTA em identificação de idioma e classificação simples de eventos com zero augmentação de áudio. A baseline do "almoço grátis".

O desbalanceamento de classes é o desafio real

ESC-50: 50 classes, 40 clipes cada — balanceado, fácil. UrbanSound8K: 10 classes, desbalanceado 10:1. AudioSet: 632 classes com uma cauda longa de 100.000:1. Técnicas que funcionam:

• Amostragem balanceada durante o treinamento (não na avaliação).
• Mixup: interpole linearmente dois clipes (e seus rótulos) como augmentação.
• SpecAugment: mascare faixas aleatórias de tempo e frequência. Simples; crítico.

Avaliação

• Multiclasse exclusiva (Speech Commands): acurácia top-1, acurácia top-5.
• Multiclasse multirrótulo (AudioSet, estilo UrbanSound): mean average precision (mAP).
• Fortemente desbalanceada: recall por classe + macro F1.

Números de 2026 que você deve conhecer:

Mãos à Obra

Passo 1: featurização

def featurize_mfcc(signal, sr, n_mfcc=13, n_mels=40, frame_len=400, hop=160):
    mag = stft_magnitude(signal, frame_len, hop)
    fb = mel_filterbank(n_mels, frame_len, sr)
    mels = apply_filterbank(mag, fb)
    log = log_transform(mels)
    return [dct_ii(frame, n_mfcc) for frame in log]

Passo 2: resumo de comprimento fixo

def summarize(mfcc_frames):
    n = len(mfcc_frames[0])
    mean = [sum(f[i] for f in mfcc_frames) / len(mfcc_frames) for i in range(n)]
    var = [
        sum((f[i] - mean[i]) ** 2 for f in mfcc_frames) / len(mfcc_frames) for i in range(n)
    ]
    return mean + var

Simples, mas forte: média + variância ao longo do tempo dão um embedding fixo de 26 dimensões para um MFCC de 13 coeficientes. Roda instantaneamente. Superou baselines de NN estado da arte no ESC-50 tão recentemente quanto 2017.

Passo 3: k-NN

def cosine(a, b):
    dot = sum(x * y for x, y in zip(a, b))
    na = math.sqrt(sum(x * x for x in a)) or 1e-12
    nb = math.sqrt(sum(x * x for x in b)) or 1e-12
    return dot / (na * nb)

def knn_classify(q, bank, labels, k=5):
    sims = sorted(range(len(bank)), key=lambda i: -cosine(q, bank[i]))[:k]
    votes = Counter(labels[i] for i in sims)
    return votes.most_common(1)[0][0]

Passo 4: evolua para uma CNN sobre log-mels

Em PyTorch:

import torch.nn as nn

class AudioCNN(nn.Module):
    def __init__(self, n_mels=80, n_classes=50):
        super().__init__()
        self.body = nn.Sequential(
            nn.Conv2d(1, 32, 3, padding=1), nn.ReLU(), nn.MaxPool2d(2),
            nn.Conv2d(32, 64, 3, padding=1), nn.ReLU(), nn.MaxPool2d(2),
            nn.Conv2d(64, 128, 3, padding=1), nn.ReLU(),
            nn.AdaptiveAvgPool2d(1),
        )
        self.head = nn.Linear(128, n_classes)

    def forward(self, x):  # x: (B, 1, T, n_mels)
        return self.head(self.body(x).flatten(1))

3M de parâmetros. Treina em ~10 min no ESC-50 com uma única RTX 4090. Mais de 80% de acurácia.

Passo 5: o padrão de 2026 — fine-tune do BEATs

from transformers import ASTFeatureExtractor, ASTForAudioClassification

ext = ASTFeatureExtractor.from_pretrained("MIT/ast-finetuned-audioset-10-10-0.4593")
model = ASTForAudioClassification.from_pretrained(
    "MIT/ast-finetuned-audioset-10-10-0.4593",
    num_labels=50,
    ignore_mismatched_sizes=True,
)

inputs = ext(audio, sampling_rate=16000, return_tensors="pt")
logits = model(**inputs).logits

Para o BEATs, use microsoft/BEATs-base por meio da biblioteca beats; a API do transformers tem o mesmo formato.

Use na Prática

A stack de 2026:

Regra de decisão: comece com um backbone congelado, não com um modelo novo. Fazer fine-tune de uma cabeça do BEATs leva você a 95% do SOTA em horas, não em semanas.

Entregue

Salve como outputs/skill-classifier-designer.md. Escolha a arquitetura, as augmentações, a estratégia de balanceamento de classes e a métrica de avaliação para uma dada tarefa de classificação de áudio.

Exercícios

1. Fácil. Execute o code/main.py. Ele treina a baseline k-NN MFCC em um conjunto de dados sintético de 4 classes (tons puros em diferentes alturas). Reporte a matriz de confusão.
2. Médio. Substitua summarize por [média, variância, assimetria, curtose]. O pooling de 4 momentos supera média+variância no mesmo conjunto de dados sintético?
3. Difícil. Usando torchaudio, treine uma CNN 2D no fold 1 do ESC-50. Reporte a acurácia de validação cruzada com 5 folds. Adicione o SpecAugment (máscara de tempo = 20, máscara de frequência = 10) e reporte o delta.

Termos-Chave

Leitura Adicional

• Gong, Chung, Glass (2021). AST: Audio Spectrogram Transformer — a arquitetura de referência de 2021–2024.
• Chen et al. (2022, rev. 2024). BEATs: Audio Pre-Training with Acoustic Tokenizers — o padrão de 2024 em diante.
• Park et al. (2019). SpecAugment — a augmentação de áudio dominante.
• Piczak (2015). ESC-50 dataset — benchmark de 50 classes que segue vivo.
• Gemmeke et al. (2017). AudioSet — taxonomia de 632 classes do YouTube; ainda é o padrão-ouro.