Como implementar classificação de áudio com Azure AI Speech: passo a passo

Este tutorial mostra como criar um pipeline simples de classificação de áudio com Azure AI Speech para diferenciar comandos ou sons (por exemplo: ‘clap’, ‘applause’, ‘speech’). Ter um classificador de áudio é útil para automatização, acessibilidade e monitorização em aplicações reais.

Pré-requisitos

• Conta Azure com subscrição ativa e Azure AI Speech configurado (key e endpoint).
• Python 3.8+ instalado e pip.
• Ficheiros de áudio WAV numa estrutura organizada por pastas (uma pasta por classe).
• Bibliotecas: azure-cognitiveservices-speech, librosa, scikit-learn, soundfile.
• Editor de texto/IDE e linha de comandos básica.

Passo 1: Porquê e escolha da abordagem

Classificar áudio pode ser feito com modelos pré-treinados ou criando um classificador simples baseado em features (MFCCs) seguido de um classificador clássico (ex.: RandomForest). Para um tutorial introdutório usamos extração de MFCC com librosa e um classificador sklearn — mais leve e explicável antes de migrar para deep learning ou Custom Speech.

Passo 2: Preparar ambiente e instalar dependências

Instale as bibliotecas necessárias. Isto inclui o SDK do Azure Speech caso pretenda integrar gravação ou transcrição, mas o núcleo da classificação usa librosa e scikit-learn.

python -m pip install azure-cognitiveservices-speech librosa scikit-learn soundfile numpy

Passo 3: Estruturar os dados de áudio

Organize os ficheiros WAV assim: dataset/clap/*.wav, dataset/applause/*.wav, dataset/speech/*.wav. Certifique-se de que os ficheiros têm a mesma taxa de amostragem (ex.: 16 kHz) ou serão convertidos ao carregar.

Passo 4: Extrair features (MFCC) do áudio

Extraímos MFCCs porque resumem bem características timbrísticas. Vamos carregar cada ficheiro, calcular MFCC médios ao longo do tempo e construir X (features) e y (labels).

import os
import numpy as np
import librosa

def extract_features(file_path, n_mfcc=13):
    y, sr = librosa.load(file_path, sr=16000)
    mfcc = librosa.feature.mfcc(y=y, sr=sr, n_mfcc=n_mfcc)
    return np.mean(mfcc, axis=1)

def load_dataset(root):
    X, y = [], []
    classes = sorted(os.listdir(root))
    for label in classes:
        folder = os.path.join(root, label)
        if not os.path.isdir(folder):
            continue
        for f in os.listdir(folder):
            if f.lower().endswith('.wav'):
                path = os.path.join(folder, f)
                features = extract_features(path)
                X.append(features)
                y.append(label)
    return np.array(X), np.array(y)

# Exemplo de uso
# X, y = load_dataset('dataset')

Passo 5: Treinar e avaliar um classificador

Usamos um RandomForest para começar. Fazemos split treino/teste e medimos accuracy e matriz de confusão para ver erros comuns (confusão entre classes semelhantes).

from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, confusion_matrix

X, y = load_dataset('dataset')
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)

clf = RandomForestClassifier(n_estimators=100, random_state=42)
clf.fit(X_train, y_train)

pred = clf.predict(X_test)
print('Accuracy:', accuracy_score(y_test, pred))
print('Confusion matrix:\n', confusion_matrix(y_test, pred))

Passo 6: Integrar com Azure AI Speech (opcional)

Se pretender capturar áudio em tempo real ou usar o serviço de gravação, use azure-cognitiveservices-speech para gravar e depois aplicar o pipeline de extração+classificação ao buffer capturado.

import azure.cognitiveservices.speech as speechsdk

speech_key = 'SUA_SPEECH_KEY'
service_region = 'SUA_REGION'

speech_config = speechsdk.SpeechConfig(subscription=speech_key, region=service_region)
audio_config = speechsdk.audio.AudioConfig(use_default_microphone=True)
rec = speechsdk.AudioConfig(use_default_microphone=True)

# Exemplo simples: grava 3s e guarda como WAV local (pode usar para classificar)
recorder = speechsdk.audio.AudioRecorder(audio_config)
# Notas: o SDK tem classes para gravação; aqui referimos a integração geral.

Verificar o resultado

Confirme que a accuracy é aceitável (ex.: >70% em dataset simples). Verifique a matriz de confusão para classes muito confundidas. Teste com novos ficheiros WAV não vistos e veja se o modelo prediz corretamente. Se utilizar o microfone via Azure AI Speech, grave áudio curto e passe pelo mesmo extract_features -> clf.predict.

Conclusão

Acabou de construir um classificador de áudio simples com extração de MFCC e RandomForest, e sabe como integrar gravação via Azure AI Speech. Próximos passos: usar data augmentation, testar modelos deep learning (CNN/LSTM) ou experimentar Custom Speech para modelos pré-treinados. Dica: se as classes forem parecidas, aumente o número de MFCCs ou experimente features adicionais (chroma, spectral contrast).