Phase 06 - Lesson 03

Clasificación de Audio — De k-NN sobre MFCCs al AST y a BEATs

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

Todo, desde "perro ladrando vs. sirena" hasta "qué idioma es este", es clasificación de audio. Las features son mels. La arquitectura cambia cada década. La evaluación sigue siendo AUC, F1 y recall por clase.

Tipo: Build Lenguajes: Python Prerrequisitos: Fase 6 · 02 (Espectrogramas y Mel), Fase 3 · 06 (CNNs), Fase 5 · 08 (CNNs y RNNs para Texto) Tiempo: ~75 minutos

El Problema

Recibes un clip de 10 segundos. Quieres saber: "¿qué es esto?" Sonido urbano (sirena, taladro, perro), comando de voz (sí/no/parar), identificación de idioma (en/es/ar), emoción del hablante (enojado/neutral) o sonido ambiental (interior/exterior, murmullo). Todo esto es clasificación de audio, y en 2026 la arquitectura de referencia está madura: log-mel → CNN o Transformer → softmax.

La dificultad central no es la red. Son los datos. Los conjuntos de datos de audio tienen un desbalance brutal de clases, un fuerte cambio de dominio (limpio vs. ruidoso) y ruido de etiqueta (¿quién decidió qué es "murmullo urbano" vs. "ruido de restaurante"?). El 80% del problema está en la curación, la augmentación y la evaluación, no en cambiar la CNN por el Transformer.

El Concepto

k-NN sobre MFCCs (la baseline de los años 1990). Aplana los MFCCs por clip, calcula la similitud de coseno respecto a un banco etiquetado y devuelve el voto mayoritario de los K más cercanos. Sorprendentemente fuerte en conjuntos de datos limpios y pequeños (Speech Commands, ESC-50). Corre sin GPU.

CNN 2D sobre log-mels (2015-2019). Trata el log-mel (T, n_mels) como una imagen. Aplica ResNet-18 o estilo VGG. Haz global mean pool sobre el eje del tiempo. Softmax sobre las clases. Sigue siendo la baseline en la mayoría de las competencias de kaggle en 2026.

Audio Spectrogram Transformer, AST (2021-2024). Divide el log-mel en patches (por ejemplo, patches 16×16), agrega embeddings de posición y aliméntalo a un ViT. Estado del arte en AudioSet (mAP 0,485) para aprendizaje supervisado.

BEATs y WavLM-base (2024-2026). Preentrenamiento autosupervisado sobre millones de horas. Haz fine-tune en tu tarea con el 1-10% de los datos supervisados que habrías necesitado. En 2026 este es el punto de partida por defecto para audio que no sea de voz. BEATs-iter3 supera al AST en 1-2 mAP en AudioSet usando 1/4 del cómputo.

Encoder de Whisper como backbone congelado (2024). Toma el encoder de Whisper, descarta el decoder y conecta un clasificador lineal. Cerca del SOTA en identificación de idioma y clasificación simple de eventos con cero augmentación de audio. La baseline del "almuerzo gratis".

El desbalance de clases es el desafío real

ESC-50: 50 clases, 40 clips cada una — balanceado, fácil. UrbanSound8K: 10 clases, desbalanceado 10:1. AudioSet: 632 clases con una cola larga de 100.000:1. Técnicas que funcionan:

• Muestreo balanceado durante el entrenamiento (no en la evaluación).
• Mixup: interpola linealmente dos clips (y sus etiquetas) como augmentación.
• SpecAugment: enmascara bandas aleatorias de tiempo y frecuencia. Simple; crítico.

Evaluación

• Multiclase exclusiva (Speech Commands): exactitud top-1, exactitud top-5.
• Multiclase multietiqueta (AudioSet, estilo UrbanSound): mean average precision (mAP).
• Fuertemente desbalanceada: recall por clase + macro F1.

Cifras de 2026 que deberías conocer:

Constrúyelo

Paso 1: featurizar

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]

Paso 2: resumen de longitud fija

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

Simple pero fuerte: media + varianza a lo largo del tiempo dan un embedding fijo de 26 dimensiones para un MFCC de 13 coeficientes. Corre instantáneamente. Superó a baselines de NN estado del arte en ESC-50 tan recientemente como en 2017.

Paso 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]

Paso 4: evoluciona a una CNN sobre log-mels

En 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. Entrena en ~10 min en ESC-50 con una sola RTX 4090. Más del 80% de exactitud.

Paso 5: el estándar de 2026 — fine-tune de 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 BEATs, usa microsoft/BEATs-base a través de la biblioteca beats; la API de transformers tiene la misma forma.

Úsalo

El stack de 2026:

Regla de decisión: empieza con un backbone congelado, no con un modelo nuevo. Hacer fine-tune de una cabeza de BEATs te lleva al 95% del SOTA en horas, no en semanas.

Entrégalo

Guárdalo como outputs/skill-classifier-designer.md. Elige la arquitectura, las augmentaciones, la estrategia de balanceo de clases y la métrica de evaluación para una tarea dada de clasificación de audio.

Ejercicios

1. Fácil. Ejecuta code/main.py. Entrena la baseline k-NN MFCC sobre un conjunto de datos sintético de 4 clases (tonos puros a distintas alturas). Reporta la matriz de confusión.
2. Medio. Reemplaza summarize por [media, varianza, asimetría, curtosis]. ¿El pooling de 4 momentos supera a media+varianza en el mismo conjunto de datos sintético?
3. Difícil. Usando torchaudio, entrena una CNN 2D en el fold 1 de ESC-50. Reporta la exactitud de validación cruzada con 5 folds. Agrega SpecAugment (máscara de tiempo = 20, máscara de frecuencia = 10) y reporta el delta.

Términos Clave

Lecturas Adicionales

• Gong, Chung, Glass (2021). AST: Audio Spectrogram Transformer — la arquitectura de referencia de 2021–2024.
• Chen et al. (2022, rev. 2024). BEATs: Audio Pre-Training with Acoustic Tokenizers — el estándar de 2024 en adelante.
• Park et al. (2019). SpecAugment — la augmentación de audio dominante.
• Piczak (2015). ESC-50 dataset — benchmark de 50 clases que sigue vigente.
• Gemmeke et al. (2017). AudioSet — taxonomía de 632 clases de YouTube; sigue siendo el estándar de oro.