README.md

---
license: apache-2.0
base_model: lgris/w2v_podcasts_base_400k_pt
tags:
- audio
- speech
- portuguese
- accent-classification
- wav2vec2
- brazil
- portugal
language:
- pt
datasets:
- mozilla-foundation/common_voice_17_0
- CORAA
- freds0/BRSpeech-TTS
widget:
- example_title: Português Brasileiro
  src: https://huggingface.co/datasets/mozilla-foundation/common_voice_13_0/resolve/main/audio/pt/clips/common_voice_pt_123.mp3
- example_title: Português Europeu  
  src: https://huggingface.co/datasets/mozilla-foundation/common_voice_13_0/resolve/main/audio/pt/clips/common_voice_pt_456.mp3
model-index:
- name: Portuguese Accent Classifier
  results:
  - task:
      type: audio-classification
      name: Audio Classification
    dataset:
      type: custom
      name: Portuguese Accents Dataset
    metrics:
    - type: accuracy
      value: 0.95
      name: Accuracy
---

# 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`](https://huggingface.co/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`](https://huggingface.co/datasets/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`](https://huggingface.co/datasets/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:

```bash
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

![Matriz de Confusão](confusion_matrix.png)

## Como Usar

### Instalação

```bash
pip install transformers torch librosa
```

### Código de Exemplo

```python
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

```python
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:

```python
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:

```bibtex
@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.