lgris/portuguese-accent-classifier

Portuguese Accent Classifier (pt_br vs pt_pt)

Este modelo foi desenvolvido para classificar automaticamente sotaques do português, distinguindo entre Português Brasileiro (pt_br) e Português Europeu/Portugal (pt_pt).

Modelo Base

O modelo foi treinado usando fine-tuning a partir do lgris/w2v_podcasts_base_400k_pt, que é baseado no Wav2Vec2 e foi pré-treinado especificamente em dados de português.

Datasets Utilizados

O modelo foi treinado utilizando uma combinação balanceada de três datasets públicos principais:

1. CORAA (Corpus of Annotated Audios)

• Descrição: Corpus brasileiro de áudios anotados com foco em português brasileiro. Foi utilizado apenas o subset do TED, que contém amostras em português brasileiro e europeu.
• Processamento: Scripts utilizados para extração e balanceamento dos dados

2. CML-TTS Portuguese

• Dataset: freds0/BRSpeech-TTS
• Descrição: Dataset brasileiro para síntese de fala
• Características: Áudios de alta qualidade com transcrições

3. Mozilla Common Voice 17.0

• Dataset: mozilla-foundation/common_voice_17_0
• Contribuição: Dados tanto de português brasileiro quanto português europeu
• Filtros aplicados:
  • pt_br: Português do Brasil
  • pt_pt: Português de Portugal
• Vantagem: Grande variedade de falantes e contextos

Preprocessamento dos Dados

O preprocessamento foi realizado através de scripts especializados localizados em scripts_preprocessamento/:

• processa_coraa.py: Processamento do dataset CORAA
• processa_cml.py: Processamento do dataset CML-TTS Portuguese
• processa_common_voice.py: Processamento do Mozilla Common Voice
• processa_cml_test.py: Processamento do dataset CML-TTS Portuguese (teste)

Estratégias de Balanceamento

1. Balanceamento entre classes: Garantiu-se quantidade similar de amostras para pt_br e pt_pt
2. Duração padronizada: Áudios processados para segmentos de até 5 segundos
3. Qualidade de áudio: Filtros aplicados para remover áudios com problemas de qualidade
4. Distribuição de falantes: Diversidade de falantes em ambas as classes

Arquitetura do Modelo

• Base: Wav2Vec2 Base (adaptado para português)
• Cabeça de classificação: Classificador binário (2 classes)
• Entrada: Áudios de até 5 segundos, 16kHz
• Saída: Probabilidades para pt_br e pt_pt

Treinamento

• Épocas: 50
• Batch Size: 32
• Learning Rate: 3e-5

Logs do Treinamento

Os logs detalhados do treinamento estão disponíveis no TensorBoard:

• Pasta de logs: runs/Aug27_19-00-18_dgx-B200-1/
• Arquivo de eventos: events.out.tfevents.1756332020.dgx-B200-1.2921567.0
• Data/Hora: 27 de agosto de 2024, 19:00:18

Para visualizar os logs do treinamento:

tensorboard --logdir=runs/Aug27_19-00-18_dgx-B200-1/

Resultados de Avaliação

O modelo foi avaliado no conjunto de teste e validação do CML contendo 2.474 amostras.

Métricas Gerais

Métrica	Valor
Acurácia	96.8%
F1-Score Macro	93.2%
F1-Score Ponderado	96.9%

Performance por Classe

Classe	Precisão	Recall	F1-Score	Suporte
pt_br	100.0%	96.6%	98.1%	2.163
pt_pt	80.8%	96.8%	88.3%	311

Relatório de Classificação Detalhado

              precision    recall  f1-score   support

       pt_br       1.00      0.97      0.98      2163
       pt_pt       0.81      0.97      0.88       311

    accuracy                           0.97      2474
   macro avg       0.90      0.97      0.93      2474
weighted avg       0.97      0.97      0.97      2474

Matriz de Confusão

Como Usar

Instalação

pip install transformers torch librosa

Código de Exemplo

from transformers import AutoFeatureExtractor, AutoModelForAudioClassification
import torch
import librosa

# Carregar modelo e feature extractor
model_name = "lgris/portuguese-accent-classifier"
feature_extractor = AutoFeatureExtractor.from_pretrained(model_name)
model = AutoModelForAudioClassification.from_pretrained(model_name)

# Carregar áudio
audio_path = "caminho/para/seu/audio.wav"
audio, sr = librosa.load(audio_path, sr=feature_extractor.sampling_rate)

# Preprocessing
inputs = feature_extractor(audio, sampling_rate=sr, return_tensors="pt", padding=True)

# Inferência
with torch.no_grad():
    outputs = model(**inputs)
    predictions = torch.nn.functional.softmax(outputs.logits, dim=-1)

# Resultado
labels = ["pt_br", "pt_pt"]
predicted_class = torch.argmax(predictions, dim=-1).item()
confidence = predictions[0][predicted_class].item()

print(f"Sotaque detectado: {labels[predicted_class]}")
print(f"Confiança: {confidence:.3f}")

Usando com Pipeline

from transformers import pipeline

classifier = pipeline(
    "audio-classification",
    model="lgris/portuguese-accent-classifier"
)

result = classifier("caminho/para/audio.wav")
print(result)

Janela Deslizante para Áudios Longos

Para áudios mais longos que 5 segundos, recomenda-se usar uma estratégia de janela deslizante:

import numpy as np

def classify_long_audio(audio_path, model, feature_extractor, window_size=5.0, overlap=2.5):
    """Classifica áudio longo usando janela deslizante"""
    audio, sr = librosa.load(audio_path, sr=feature_extractor.sampling_rate)
    
    if len(audio) <= sr * window_size:
        # Áudio curto, classificação direta
        return classify_audio_segment(audio, model, feature_extractor)
    
    # Janela deslizante para áudios longos
    window_samples = int(sr * window_size)
    step_samples = int(sr * overlap)
    
    predictions = []
    confidences = []
    
    for start in range(0, len(audio) - window_samples + 1, step_samples):
        segment = audio[start:start + window_samples]
        pred, conf = classify_audio_segment(segment, model, feature_extractor)
        predictions.append(pred)
        confidences.append(conf)
    
    # Combinar predições (voto majoritário ponderado)
    return combine_predictions(predictions, confidences)

def classify_audio_segment(audio, model, feature_extractor):
    """Classifica um segmento de áudio"""
    inputs = feature_extractor(audio, sampling_rate=feature_extractor.sampling_rate, return_tensors="pt", padding=True)
    
    with torch.no_grad():
        outputs = model(**inputs)
        predictions = torch.nn.functional.softmax(outputs.logits, dim=-1)
    
    predicted_class = torch.argmax(predictions, dim=-1).item()
    confidence = predictions[0][predicted_class].item()
    
    return predicted_class, confidence

def combine_predictions(predictions, confidences):
    """Combina múltiplas predições usando voto majoritário ponderado"""
    labels = ["pt_br", "pt_pt"]
    
    # Calcular média ponderada das predições
    weighted_votes = {0: 0, 1: 0}
    
    for pred, conf in zip(predictions, confidences):
        weighted_votes[pred] += conf
    
    final_prediction = max(weighted_votes, key=weighted_votes.get)
    final_confidence = weighted_votes[final_prediction] / sum(weighted_votes.values())
    
    return labels[final_prediction], final_confidence

Citação

Se você usar este modelo em sua pesquisa, por favor cite:

@misc{portuguese-accent-classifier,
  title={Brazilian and European Portuguese Accent Classifier},
  author={Lucas Gris},
  year={2024},
  publisher={Hugging Face},
  howpublished={\url{https://huggingface.co/lgris/portuguese-accent-classifier}},
  note={Treinado em 27 de agosto de 2024 usando datasets CORAA, CML-TTS Portuguese e Mozilla Common Voice}
}

Licença

Este modelo está disponível sob a licença Apache 2.0. Consulte os datasets originais para suas respectivas licenças.