Upload Portuguese accent classifier with TensorBoard logs

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+confusion_matrix.png filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,278 @@
+---
+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_13_0
+- C4AI/brspeech
+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
+- **Contribuição**: Dados de português brasileiro (pt_br)
+- **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
+- **Contribuição**: Dados adicionais de português brasileiro (pt_br)
+- **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 Large XLSR-53 (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.

config.json

@@ -0,0 +1,120 @@
+{
+  "activation_dropout": 0.1,
+  "adapter_attn_dim": null,
+  "adapter_kernel_size": 3,
+  "adapter_stride": 2,
+  "add_adapter": false,
+  "apply_spec_augment": true,
+  "architectures": [
+    "Wav2Vec2ForSequenceClassification"
+  ],
+  "attention_dropout": 0.1,
+  "bos_token_id": 1,
+  "classifier_proj_size": 256,
+  "codevector_dim": 256,
+  "contrastive_logits_temperature": 0.1,
+  "conv_bias": false,
+  "conv_dim": [
+    512,
+    512,
+    512,
+    512,
+    512,
+    512,
+    512
+  ],
+  "conv_kernel": [
+    10,
+    3,
+    3,
+    3,
+    3,
+    2,
+    2
+  ],
+  "conv_stride": [
+    5,
+    2,
+    2,
+    2,
+    2,
+    2,
+    2
+  ],
+  "ctc_loss_reduction": "sum",
+  "ctc_zero_infinity": false,
+  "diversity_loss_weight": 0.1,
+  "do_stable_layer_norm": false,
+  "eos_token_id": 2,
+  "feat_extract_activation": "gelu",
+  "feat_extract_norm": "group",
+  "feat_proj_dropout": 0.0,
+  "feat_quantizer_dropout": 0.0,
+  "final_dropout": 0.1,
+  "hidden_act": "gelu",
+  "hidden_dropout": 0.1,
+  "hidden_size": 768,
+  "id2label": {
+    "0": "pt_br",
+    "1": "pt_pt"
+  },
+  "initializer_range": 0.02,
+  "intermediate_size": 3072,
+  "label2id": {
+    "pt_br": 0,
+    "pt_pt": 1
+  },
+  "layer_norm_eps": 1e-05,
+  "layerdrop": 0.1,
+  "mask_feature_length": 10,
+  "mask_feature_min_masks": 0,
+  "mask_feature_prob": 0.0,
+  "mask_time_length": 10,
+  "mask_time_min_masks": 2,
+  "mask_time_prob": 0.05,
+  "model_type": "wav2vec2",
+  "num_adapter_layers": 3,
+  "num_attention_heads": 12,
+  "num_codevector_groups": 2,
+  "num_codevectors_per_group": 320,
+  "num_conv_pos_embedding_groups": 16,
+  "num_conv_pos_embeddings": 128,
+  "num_feat_extract_layers": 7,
+  "num_hidden_layers": 12,
+  "num_negatives": 100,
+  "output_hidden_size": 768,
+  "pad_token_id": 0,
+  "proj_codevector_dim": 256,
+  "tdnn_dilation": [
+    1,
+    2,
+    3,
+    1,
+    1
+  ],
+  "tdnn_dim": [
+    512,
+    512,
+    512,
+    512,
+    1500
+  ],
+  "tdnn_kernel": [
+    5,
+    3,
+    3,
+    1,
+    1
+  ],
+  "torch_dtype": "float32",
+  "transformers_version": "4.55.0",
+  "use_weighted_layer_sum": false,
+  "vocab_size": 32,
+  "xvector_output_dim": 512,
+  "task_specific_params": {
+    "audio-classification": {
+      "problem_type": "single_label_classification",
+      "num_labels": 2
+    }
+  }
+}

infer_audio_folder.py

@@ -0,0 +1,495 @@
+#!/usr/bin/env python3
+"""
+Script para inferência em pasta de áudios sem labels conhecidas.
+Classifica todos os áudios recursivamente e salva resultados em CSV.
+Também salva amostras para verificação qualitativa.
+"""
+
+import os
+import sys
+import argparse
+import glob
+import torch
+import librosa
+import numpy as np
+import pandas as pd
+import shutil
+from pathlib import Path
+from transformers import AutoFeatureExtractor, AutoModelForAudioClassification
+from collections import Counter
+import random
+from datetime import datetime
+
+class AudioInference:
+    def __init__(self, model_path, device=None):
+        """
+        Inicializa o classificador de áudio.
+        """
+        self.model_path = model_path
+        self.device = device or torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        
+        # Mapeamento de classes
+        self.label_map = {0: "pt_br", 1: "pt_pt"}
+        
+        # Carregar modelo
+        self._load_model()
+    
+    def _load_model(self):
+        """Carrega o modelo e feature extractor."""
+        print(f"Carregando modelo de: {self.model_path}")
+        print(f"Usando device: {self.device}")
+        
+        try:
+            self.feature_extractor = AutoFeatureExtractor.from_pretrained(self.model_path)
+            self.model = AutoModelForAudioClassification.from_pretrained(self.model_path)
+            
+            self.model.to(self.device)
+            self.model.eval()
+            
+            print("✓ Modelo carregado com sucesso!")
+            
+        except Exception as e:
+            print(f"✗ Erro ao carregar modelo: {e}")
+            sys.exit(1)
+    
+    def load_audio(self, file_path):
+        """
+        Carrega um arquivo de áudio.
+        """
+        try:
+            audio, sr = librosa.load(
+                file_path, 
+                sr=self.feature_extractor.sampling_rate, 
+                mono=True
+            )
+            return audio, sr
+        except Exception as e:
+            print(f"Erro ao carregar {file_path}: {e}")
+            return None, None
+    
+    def predict(self, audio_path):
+        """
+        Classifica um único arquivo de áudio usando janela deslizante.
+        """
+        # Carregar áudio
+        audio, sr = self.load_audio(audio_path)
+        if audio is None:
+            return None, None, None
+        
+        try:
+            # Configurações da janela deslizante
+            window_size = int(sr * 5.0)  # Janela de 5 segundos
+            overlap = int(sr * 2.5)      # Sobreposição de 2.5 segundos (50%)
+            
+            # Se o áudio é menor que a janela, usar áudio completo
+            if len(audio) <= window_size:
+                return self._predict_segment(audio, sr)
+            
+            # Aplicar janela deslizante
+            predictions_list = []
+            confidences_list = []
+            
+            start = 0
+            while start < len(audio):
+                end = min(start + window_size, len(audio))
+                segment = audio[start:end]
+                
+                # Garantir que o segmento tenha tamanho mínimo (1 segundo)
+                if len(segment) >= sr:
+                    pred_label, confidence, class_id = self._predict_segment(segment, sr)
+                    if pred_label is not None:
+                        predictions_list.append(class_id)
+                        confidences_list.append(confidence)
+                
+                # Avançar janela
+                start += window_size - overlap
+                
+                # Se chegou no final, parar
+                if end == len(audio):
+                    break
+            
+            if not predictions_list:
+                return None, None, None
+            
+            # Combinar predições usando voto majoritário ponderado pela confiança
+            return self._combine_predictions(predictions_list, confidences_list)
+            
+        except Exception as e:
+            print(f"Erro ao processar {audio_path}: {e}")
+            return None, None, None
+    
+    def _predict_segment(self, audio_segment, sr):
+        """
+        Classifica um segmento individual de áudio.
+        """
+        try:
+            # Pré-processar segmento
+            inputs = self.feature_extractor(
+                audio_segment, 
+                sampling_rate=sr, 
+                max_length=int(sr * 5.0),
+                truncation=True,
+                padding=True,
+                return_tensors="pt"
+            )
+            
+            # Mover para device
+            inputs = {k: v.to(self.device) for k, v in inputs.items()}
+            
+            # Fazer predição
+            with torch.no_grad():
+                outputs = self.model(**inputs)
+                predictions = torch.nn.functional.softmax(outputs.logits, dim=-1)
+                predicted_class_id = predictions.argmax().item()
+                confidence = predictions.max().item()
+            
+            predicted_label = self.label_map[predicted_class_id]
+            
+            return predicted_label, confidence, predicted_class_id
+            
+        except Exception as e:
+            return None, None, None
+    
+    def _combine_predictions(self, predictions_list, confidences_list):
+        """
+        Combina múltiplas predições usando voto majoritário ponderado pela confiança.
+        """
+        # Converter para arrays numpy
+        predictions = np.array(predictions_list)
+        confidences = np.array(confidences_list)
+        
+        # Calcular pontuações ponderadas para cada classe
+        class_scores = {}
+        for class_id in [0, 1]:  # pt_br=0, pt_pt=1
+            mask = predictions == class_id
+            if np.any(mask):
+                # Somar confiança de todas as predições desta classe
+                class_scores[class_id] = np.sum(confidences[mask])
+            else:
+                class_scores[class_id] = 0.0
+        
+        # Classe com maior pontuação
+        predicted_class_id = max(class_scores.keys(), key=lambda k: class_scores[k])
+        
+        # Confiança final: média das confiânças da classe vencedora
+        winner_mask = predictions == predicted_class_id
+        if np.any(winner_mask):
+            final_confidence = np.mean(confidences[winner_mask])
+        else:
+            final_confidence = 0.0
+        
+        predicted_label = self.label_map[predicted_class_id]
+        
+        return predicted_label, final_confidence, predicted_class_id
+
+def find_audio_files(folder_path, supported_formats=None):
+    """
+    Encontra todos os arquivos de áudio recursivamente.
+    """
+    if supported_formats is None:
+        supported_formats = ['.wav', '.mp3', '.flac', '.m4a', '.ogg', '.aac']
+    
+    audio_files = []
+    for root, dirs, files in os.walk(folder_path):
+        for file in files:
+            if any(file.lower().endswith(ext) for ext in supported_formats):
+                full_path = os.path.join(root, file)
+                audio_files.append(full_path)
+    
+    return audio_files
+
+def process_audio_folder(inference_engine, audio_folder, output_csv, samples_folder=None, 
+                        samples_per_class=10, supported_formats=None):
+    """
+    Processa uma pasta de áudios recursivamente usando janela deslizante.
+    """
+    print(f"Processando pasta: {audio_folder}")
+    print("Usando janela deslizante de 5s com sobreposição de 2.5s para áudios longos")
+    
+    # Encontrar todos os arquivos de áudio
+    print("Buscando arquivos de áudio...")
+    audio_files = find_audio_files(audio_folder, supported_formats)
+    
+    # # shuffle
+    # random.shuffle(audio_files)
+    # audio_files = audio_files[0:100]
+    if not audio_files:
+        print(f"✗ Nenhum arquivo de áudio encontrado em {audio_folder}")
+        print(f"Formatos suportados: {supported_formats}")
+        return
+    
+    print(f"✓ Encontrados {len(audio_files)} arquivos de áudio")
+    
+    # Resultados
+    results = []
+    processed_count = 0
+    error_count = 0
+    total_segments = 0
+    
+    print("\nProcessando arquivos...")
+    for i, audio_file in enumerate(audio_files, 1):
+        if i % 50 == 0 or i == len(audio_files):
+            print(f"Progresso: {i}/{len(audio_files)} ({(i/len(audio_files)*100):.1f}%)")
+        
+        # Classificar áudio
+        predicted_label, confidence, class_id = inference_engine.predict(audio_file)
+        
+        if predicted_label is not None:
+            # Calcular caminho relativo
+            rel_path = os.path.relpath(audio_file, audio_folder)
+            
+            # Calcular duração do áudio para estatísticas
+            try:
+                import librosa
+                audio_duration = librosa.get_duration(filename=audio_file)
+                segments_used = max(1, int((audio_duration - 5.0) / 2.5) + 1) if audio_duration > 5.0 else 1
+                total_segments += segments_used
+            except:
+                audio_duration = None
+                segments_used = 1
+            
+            result = {
+                'arquivo': os.path.basename(audio_file),
+                'caminho_relativo': rel_path,
+                'caminho_completo': audio_file,
+                'label_predita': predicted_label,
+                'confianca': confidence,
+                'classe_id': class_id,
+                'duracao_segundos': audio_duration,
+                'segmentos_analisados': segments_used,
+                'timestamp': datetime.now().isoformat()
+            }
+            results.append(result)
+            processed_count += 1
+        else:
+            error_count += 1
+    
+    print(f"\n✓ Processamento concluído!")
+    print(f"Arquivos processados: {processed_count}")
+    print(f"Arquivos com erro: {error_count}")
+    print(f"Total de segmentos analisados: {total_segments}")
+    
+    if not results:
+        print("✗ Nenhum arquivo foi processado com sucesso.")
+        return
+    
+    # Criar DataFrame
+    df = pd.DataFrame(results)
+    
+    # Estatísticas
+    print(f"\n=== Estatísticas ===")
+    distribution = Counter(df['label_predita'])
+    for label, count in distribution.items():
+        percentage = (count / len(results)) * 100
+        print(f"{label}: {count} arquivos ({percentage:.1f}%)")
+    
+    avg_confidence = df['confianca'].mean()
+    print(f"Confiança média: {avg_confidence:.3f}")
+    
+    # Arquivos com baixa confiança
+    low_confidence_threshold = 0.7
+    low_confidence = df[df['confianca'] < low_confidence_threshold]
+    print(f"Arquivos com baixa confiança (< {low_confidence_threshold}): {len(low_confidence)} ({len(low_confidence)/len(df)*100:.1f}%)")
+    
+    # Salvar CSV
+    df.to_csv(output_csv, index=False)
+    print(f"\n✓ Resultados salvos em: {output_csv}")
+    
+    # Salvar amostras para verificação qualitativa
+    if samples_folder:
+        save_quality_samples(df, audio_folder, samples_folder, samples_per_class)
+    
+    return df
+
+def save_quality_samples(df, source_folder, samples_folder, samples_per_class=10):
+    """
+    Salva amostras de cada classe para verificação qualitativa.
+    """
+    print(f"\nSalvando amostras para verificação qualitativa...")
+    
+    # Criar pasta de amostras
+    os.makedirs(samples_folder, exist_ok=True)
+    
+    # Para cada classe
+    for label in df['label_predita'].unique():
+        print(f"Salvando amostras da classe: {label}")
+        
+        # Criar subpasta para a classe
+        class_folder = os.path.join(samples_folder, label)
+        os.makedirs(class_folder, exist_ok=True)
+        
+        # Filtrar arquivos da classe
+        class_files = df[df['label_predita'] == label]
+        
+        # Estratégia de amostragem: metade com alta confiança, metade aleatória
+        high_conf = class_files[class_files['confianca'] >= 0.8].sample(
+            n=min(samples_per_class//2, len(class_files[class_files['confianca'] >= 0.8])),
+            random_state=42
+        ) if len(class_files[class_files['confianca'] >= 0.8]) > 0 else pd.DataFrame()
+        
+        remaining_needed = samples_per_class - len(high_conf)
+        if remaining_needed > 0:
+            remaining_files = class_files[~class_files.index.isin(high_conf.index)]
+            random_sample = remaining_files.sample(
+                n=min(remaining_needed, len(remaining_files)),
+                random_state=42
+            ) if len(remaining_files) > 0 else pd.DataFrame()
+        else:
+            random_sample = pd.DataFrame()
+        
+        # Combinar amostras
+        samples = pd.concat([high_conf, random_sample]).head(samples_per_class)
+        
+        # Copiar arquivos
+        sample_info = []
+        for idx, row in samples.iterrows():
+            source_path = row['caminho_completo']
+            filename = row['arquivo']
+            confidence = row['confianca']
+            
+            # Nome do arquivo com confiança
+            name, ext = os.path.splitext(filename)
+            new_filename = f"{name}_conf{confidence:.3f}{ext}"
+            
+            dest_path = os.path.join(class_folder, new_filename)
+            
+            try:
+                shutil.copy2(source_path, dest_path)
+                sample_info.append({
+                    'arquivo_original': filename,
+                    'arquivo_copia': new_filename,
+                    'confianca': confidence,
+                    'caminho_original': row['caminho_relativo']
+                })
+            except Exception as e:
+                print(f"Erro ao copiar {source_path}: {e}")
+        
+        # Salvar informações das amostras
+        if sample_info:
+            sample_df = pd.DataFrame(sample_info)
+            info_file = os.path.join(class_folder, "info_amostras.csv")
+            sample_df.to_csv(info_file, index=False)
+            
+            print(f"  ✓ {len(sample_info)} amostras salvas em {class_folder}")
+        else:
+            print(f"  ✗ Nenhuma amostra salva para {label}")
+    
+    print(f"✓ Amostras salvas em: {samples_folder}")
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Inferência em pasta de áudios sem labels conhecidas"
+    )
+    parser.add_argument(
+        "audio_folder", 
+        help="Pasta raiz contendo arquivos de áudio (busca recursiva)"
+    )
+    parser.add_argument(
+        "--model_path", 
+        default="./nn/results/final_model",
+        help="Caminho para o modelo treinado"
+    )
+    parser.add_argument(
+        "--output", 
+        default="inferencia_resultados.csv",
+        help="Arquivo CSV para salvar resultados"
+    )
+    parser.add_argument(
+        "--samples_folder",
+        default="amostras_verificacao",
+        help="Pasta para salvar amostras para verificação qualitativa"
+    )
+    parser.add_argument(
+        "--samples_per_class",
+        type=int,
+        default=100,
+        help="Número de amostras por classe para verificação"
+    )
+    parser.add_argument(
+        "--no_samples",
+        action="store_true",
+        help="Não salvar amostras para verificação"
+    )
+    parser.add_argument(
+        "--formats", 
+        nargs="+",
+        default=['.wav', '.mp3', '.flac', '.m4a', '.ogg', '.aac'],
+        help="Formatos de áudio suportados"
+    )
+    
+    args = parser.parse_args()
+    
+    # Validações
+    if not os.path.exists(args.audio_folder):
+        print(f"✗ Pasta '{args.audio_folder}' não encontrada!")
+        sys.exit(1)
+    
+    if not os.path.exists(args.model_path):
+        print(f"✗ Modelo '{args.model_path}' não encontrado!")
+        sys.exit(1)
+    
+    print("=== Inferência em Pasta de Áudios ===")
+    print(f"Pasta de áudio: {args.audio_folder}")
+    print(f"Modelo: {args.model_path}")
+    print(f"Arquivo de saída: {args.output}")
+    
+    if not args.no_samples:
+        print(f"Pasta de amostras: {args.samples_folder}")
+        print(f"Amostras por classe: {args.samples_per_class}")
+    
+    print(f"Formatos suportados: {args.formats}")
+    print()
+    
+    # Inicializar inferência
+    inference_engine = AudioInference(args.model_path)
+    
+    # Processar pasta
+    samples_folder = None if args.no_samples else args.samples_folder
+    
+    df = process_audio_folder(
+        inference_engine=inference_engine,
+        audio_folder=args.audio_folder,
+        output_csv=args.output,
+        samples_folder=samples_folder,
+        samples_per_class=args.samples_per_class,
+        supported_formats=args.formats
+    )
+    
+    if df is not None:
+        print("\n=== Resumo Final ===")
+        print(f"Total de arquivos processados: {len(df)}")
+        print(f"Resultados salvos em: {args.output}")
+        
+        if not args.no_samples:
+            print(f"Amostras para verificação em: {args.samples_folder}")
+        
+        print("\nClassificação concluída com sucesso! 🎉")
+
+if __name__ == "__main__":
+    # Mostrar ajuda se nenhum argumento
+    if len(sys.argv) == 1:
+        print("=== Script de Inferência de Áudios ===")
+        print()
+        print("Este script classifica áudios em uma pasta recursivamente.")
+        print("Não precisa de labels conhecidas - classifica tudo automaticamente.")
+        print()
+        print("Uso básico:")
+        print("  python infer_audio_folder.py <pasta_de_audios>")
+        print()
+        print("Exemplos:")
+        print("  python infer_audio_folder.py ../audios_novos")
+        print("  python infer_audio_folder.py ../dataset --output resultados.csv")
+        print("  python infer_audio_folder.py ../audios --samples_per_class 20")
+        print("  python infer_audio_folder.py ../audios --no_samples")
+        print()
+        print("O que o script faz:")
+        print("1. Busca recursivamente todos os arquivos de áudio")
+        print("2. Classifica cada um como pt_br ou pt_pt")
+        print("3. Salva resultados detalhados em CSV")
+        print("4. Cria amostras para verificação manual")
+        print("5. Mostra estatísticas dos resultados")
+        print()
+        print("Para ver todas as opções: python infer_audio_folder.py --help")
+        sys.exit(0)
+    
+    main()

model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0c0d556cb002720ef5967062587af31f524ced066232af0448d0876d0221a2c8
+size 378302360

preprocessor_config.json

@@ -0,0 +1,9 @@
+{
+  "do_normalize": true,
+  "feature_extractor_type": "Wav2Vec2FeatureExtractor",
+  "feature_size": 1,
+  "padding_side": "right",
+  "padding_value": 0.0,
+  "return_attention_mask": false,
+  "sampling_rate": 16000
+}

runs/Aug27_19-00-18_dgx-B200-1/events.out.tfevents.1756332020.dgx-B200-1.2921567.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2d5a3159be67810fda04dd173218eeebfae90d9948586f0f24b2d92eaf48a226
+size 170555

scripts_preprocessamento/processa_cml.py

@@ -0,0 +1,82 @@
+import pandas as pd
+import os
+import librosa
+import soundfile as sf
+from tqdm import tqdm
+
+# --- Configurações ---
+TARGET_SR = 16000
+
+# Caminhos de entrada
+BASE_DATA_PATH = '../data/cml/'
+METADATA_FILE = os.path.join(BASE_DATA_PATH, 'train.csv')
+
+# Caminho de saída
+OUTPUT_PATH = '../dataset_preparado/'
+OUTPUT_BR_PATH = os.path.join(OUTPUT_PATH, 'pt_br')
+OUTPUT_PT_PATH = os.path.join(OUTPUT_PATH, 'pt_pt')
+
+# --- Mapeamento de Labels ---
+ACCENT_MAP = {
+    'BR': 'pt_br',
+    'EU': 'pt_pt'
+}
+PATH_MAP = {
+    'pt_br': OUTPUT_BR_PATH,
+    'pt_pt': OUTPUT_PT_PATH
+}
+
+def preprocess_cml():
+    print("Iniciando o pré-processamento do CML...")
+
+    os.makedirs(OUTPUT_BR_PATH, exist_ok=True)
+    os.makedirs(OUTPUT_PT_PATH, exist_ok=True)
+
+    try:
+        df = pd.read_csv(METADATA_FILE, sep='|')
+    except FileNotFoundError:
+        print(f"Erro: Arquivo de metadados não encontrado em {METADATA_FILE}")
+        return
+
+    df = df[['wav_filename', 'accent']].dropna()
+    df = df[df['accent'].isin(ACCENT_MAP.keys())]
+    df['label'] = df['accent'].map(ACCENT_MAP)
+    
+    print(f"Amostras encontradas por sotaque (antes do balanceamento):\n{df['label'].value_counts()}")
+
+    # --- Lógica de Amostragem Aleatória e Balanceamento ---
+    class_counts = df['label'].value_counts().to_dict()
+    if not class_counts or len(class_counts) < 2:
+        print("Erro: Não foram encontradas amostras suficientes de ambas as classes para balancear.")
+        return
+        
+    min_samples = min(class_counts.values())
+    print(f"Classe minoritária tem {min_samples} amostras. Usando este valor para o balanceamento.")
+    
+    df = df.sample(frac=1).reset_index(drop=True)
+    
+    max_samples_per_class = min_samples
+    counters = {'pt_br': 0, 'pt_pt': 0}
+
+    for _, row in tqdm(df.iterrows(), total=df.shape[0], desc="Processando áudios"):
+        label = row['label']
+        
+        if counters[label] >= max_samples_per_class:
+            continue
+
+        source_audio_path = os.path.join(BASE_DATA_PATH, row['wav_filename'])
+        filename = row['wav_filename'].replace('/', '_')
+        dest_path = os.path.join(PATH_MAP[label], f"cml_{filename}")
+
+        try:
+            audio, sr = librosa.load(source_audio_path, sr=TARGET_SR, mono=True)
+            sf.write(dest_path, audio, TARGET_SR)
+            counters[label] += 1
+        except Exception as e:
+            print(f"Aviso: Não foi possível processar {source_audio_path}. Erro: {e}")
+
+    print("\nPré-processamento do CML concluído!")
+    print(f"Amostras salvas (balanceado): {counters}")
+
+if __name__ == '__main__':
+    preprocess_cml()

scripts_preprocessamento/processa_cml_test.py

@@ -0,0 +1,65 @@
+import pandas as pd
+import os
+import librosa
+import soundfile as sf
+from tqdm import tqdm
+
+# --- Configurações ---
+TARGET_SR = 16000
+
+# Caminhos de entrada
+BASE_DATA_PATH = '../data/cml/'
+METADATA_FILE = os.path.join(BASE_DATA_PATH, 'dev_and_test.csv')
+
+# Caminho de saída
+OUTPUT_PATH = '../dataset_preparado/test'
+OUTPUT_BR_PATH = os.path.join(OUTPUT_PATH, 'pt_br')
+OUTPUT_PT_PATH = os.path.join(OUTPUT_PATH, 'pt_pt')
+
+# --- Mapeamento de Labels ---
+ACCENT_MAP = {
+    'BR': 'pt_br',
+    'EU': 'pt_pt'
+}
+PATH_MAP = {
+    'pt_br': OUTPUT_BR_PATH,
+    'pt_pt': OUTPUT_PT_PATH
+}
+
+def preprocess_cml():
+    print("Iniciando o pré-processamento do CML...")
+
+    os.makedirs(OUTPUT_BR_PATH, exist_ok=True)
+    os.makedirs(OUTPUT_PT_PATH, exist_ok=True)
+
+    try:
+        df = pd.read_csv(METADATA_FILE, sep='|')
+    except FileNotFoundError:
+        print(f"Erro: Arquivo de metadados não encontrado em {METADATA_FILE}")
+        return
+
+    df = df[['wav_filename', 'accent']].dropna()
+    df = df[df['accent'].isin(ACCENT_MAP.keys())]
+    df['label'] = df['accent'].map(ACCENT_MAP)
+    
+    counters = {'pt_br': 0, 'pt_pt': 0}
+
+    for _, row in tqdm(df.iterrows(), total=df.shape[0], desc="Processando áudios"):
+        label = row['label']
+
+        source_audio_path = os.path.join(BASE_DATA_PATH, row['wav_filename'])
+        filename = row['wav_filename'].replace('/', '_')
+        dest_path = os.path.join(PATH_MAP[label], f"cml_{filename}")
+
+        try:
+            audio, sr = librosa.load(source_audio_path, sr=TARGET_SR, mono=True)
+            sf.write(dest_path, audio, TARGET_SR)
+            counters[label] += 1
+        except Exception as e:
+            print(f"Aviso: Não foi possível processar {source_audio_path}. Erro: {e}")
+
+    print("\nPré-processamento do CML concluído!")
+    print(f"Amostras salvas (balanceado): {counters}")
+
+if __name__ == '__main__':
+    preprocess_cml()

scripts_preprocessamento/processa_common_voice.py

@@ -0,0 +1,85 @@
+import pandas as pd
+import os
+import librosa
+import soundfile as sf
+from tqdm import tqdm
+
+# --- Configurações ---
+TARGET_SR = 16000
+
+# Caminhos de entrada
+BASE_DATA_PATH = '../data/common_voice/cv-corpus-22.0-2025-06-20/pt/'
+METADATA_FILE = os.path.join(BASE_DATA_PATH, 'validated.tsv')
+AUDIO_CLIPS_PATH = os.path.join(BASE_DATA_PATH, 'clips')
+
+# Caminho de saída
+OUTPUT_PATH = '../dataset_preparado/'
+OUTPUT_BR_PATH = os.path.join(OUTPUT_PATH, 'pt_br')
+OUTPUT_PT_PATH = os.path.join(OUTPUT_PATH, 'pt_pt')
+
+# --- Mapeamento de Labels ---
+VARIANT_MAP = {
+    'Portuguese (Brasil)': 'pt_br',
+    'Portuguese (Portugal)': 'pt_pt'
+}
+PATH_MAP = {
+    'pt_br': OUTPUT_BR_PATH,
+    'pt_pt': OUTPUT_PT_PATH
+}
+
+def preprocess_common_voice():
+    print("Iniciando o pré-processamento do Common Voice...")
+
+    os.makedirs(OUTPUT_BR_PATH, exist_ok=True)
+    os.makedirs(OUTPUT_PT_PATH, exist_ok=True)
+
+    try:
+        df = pd.read_csv(METADATA_FILE, sep='\t')
+    except FileNotFoundError:
+        print(f"Erro: Arquivo de metadados não encontrado em {METADATA_FILE}")
+        return
+
+    df = df[['path', 'variant']].dropna()
+    df = df[df['variant'].isin(VARIANT_MAP.keys())]
+    df['label'] = df['variant'].map(VARIANT_MAP)
+
+    print(f"Amostras encontradas por sotaque (antes do balanceamento):\n{df['label'].value_counts()}")
+
+    # --- Lógica de Amostragem Aleatória e Balanceamento ---
+    class_counts = df['label'].value_counts().to_dict()
+    if not class_counts or len(class_counts) < 2:
+        print("Erro: Não foram encontradas amostras suficientes de ambas as classes para balancear.")
+        return
+        
+    min_samples = min(class_counts.values())
+    print(f"Classe minoritária tem {min_samples} amostras. Usando este valor para o balanceamento.")
+
+    # Embaralhar o dataframe para garantir amostragem aleatória
+    df = df.sample(frac=1).reset_index(drop=True)
+    
+    # O limite agora é dinâmico
+    max_samples_per_class = min_samples 
+    counters = {'pt_br': 0, 'pt_pt': 0}
+
+    for _, row in tqdm(df.iterrows(), total=df.shape[0], desc="Processando áudios"):
+        label = row['label']
+        
+        if counters[label] >= max_samples_per_class:
+            continue
+
+        source_audio_path = os.path.join(AUDIO_CLIPS_PATH, row['path'])
+        filename = os.path.splitext(row['path'])[0] + '.wav'
+        dest_path = os.path.join(PATH_MAP[label], f"cv_{filename}")
+
+        try:
+            audio, sr = librosa.load(source_audio_path, sr=TARGET_SR, mono=True)
+            sf.write(dest_path, audio, TARGET_SR)
+            counters[label] += 1
+        except Exception as e:
+            print(f"Aviso: Não foi possível processar {source_audio_path}. Erro: {e}")
+
+    print("\nPré-processamento do Common Voice concluído!")
+    print(f"Amostras salvas (balanceado): {counters}")
+
+if __name__ == '__main__':
+    preprocess_common_voice()

scripts_preprocessamento/processa_coraa.py

@@ -0,0 +1,83 @@
+import pandas as pd
+import os
+import librosa
+import soundfile as sf
+from tqdm import tqdm
+
+# --- Configurações ---
+TARGET_SR = 16000
+TARGET_SUBSET = "TEDx Talks"
+
+# Caminhos de entrada
+BASE_DATA_PATH = '../data/coraa/'
+METADATA_FILE = os.path.join(BASE_DATA_PATH, 'metadata_train_final.csv')
+
+# Caminho de saída
+OUTPUT_PATH = '../dataset_preparado/'
+OUTPUT_BR_PATH = os.path.join(OUTPUT_PATH, 'pt_br')
+OUTPUT_PT_PATH = os.path.join(OUTPUT_PATH, 'pt_pt')
+
+# --- Mapeamento ---
+PATH_MAP = {
+    'pt_br': OUTPUT_BR_PATH,
+    'pt_pt': OUTPUT_PT_PATH
+}
+
+def preprocess_coraa():
+    print(f"Iniciando o pré-processamento do CORAA (filtrando por '{TARGET_SUBSET}')...")
+
+    os.makedirs(OUTPUT_BR_PATH, exist_ok=True)
+    os.makedirs(OUTPUT_PT_PATH, exist_ok=True)
+
+    try:
+        df = pd.read_csv(METADATA_FILE)
+    except FileNotFoundError:
+        print(f"Erro: Arquivo de metadados não encontrado em {METADATA_FILE}")
+        return
+        
+    # --- Adicionado: Filtro para o subset TEDx Talks ---
+    df = df[df['dataset'] == TARGET_SUBSET].copy()
+    print(f"Encontradas {len(df)} amostras no subset '{TARGET_SUBSET}'.")
+
+    df = df[['file_path', 'variety']].dropna()
+    df = df[df['variety'].isin(['pt_br', 'pt_pt'])]
+    df.rename(columns={'variety': 'label'}, inplace=True)
+    
+    print(f"Amostras encontradas por sotaque (antes do balanceamento):\n{df['label'].value_counts()}")
+
+    # --- Lógica de Amostragem Aleatória e Balanceamento ---
+    class_counts = df['label'].value_counts().to_dict()
+    if not class_counts or len(class_counts) < 2:
+        print("Erro: Não foram encontradas amostras suficientes de ambas as classes no subset TEDx para balancear.")
+        return
+
+    min_samples = min(class_counts.values())
+    print(f"Classe minoritária tem {min_samples} amostras. Usando este valor para o balanceamento.")
+    
+    df = df.sample(frac=1).reset_index(drop=True)
+    
+    max_samples_per_class = min_samples
+    counters = {'pt_br': 0, 'pt_pt': 0}
+
+    for _, row in tqdm(df.iterrows(), total=df.shape[0], desc="Processando áudios"):
+        label = row['label']
+        
+        if counters[label] >= max_samples_per_class:
+            continue
+
+        source_audio_path = os.path.join(BASE_DATA_PATH, row['file_path'])
+        filename = os.path.basename(row['file_path'])
+        dest_path = os.path.join(PATH_MAP[label], f"coraa_tedx_{filename}")
+
+        try:
+            audio, sr = librosa.load(source_audio_path, sr=TARGET_SR, mono=True)
+            sf.write(dest_path, audio, TARGET_SR)
+            counters[label] += 1
+        except Exception as e:
+            print(f"Aviso: Não foi possível processar {source_audio_path}. Erro: {e}")
+
+    print("\nPré-processamento do CORAA (TEDx) concluído!")
+    print(f"Amostras salvas (balanceado): {counters}")
+
+if __name__ == '__main__':
+    preprocess_coraa()

test_audio_folder.py

@@ -0,0 +1,547 @@
+#!/usr/bin/env python3
+"""
+Script para testar classificação de sotaques em uma pasta de áudios.
+Este script carrega o modelo treinado e classifica todos os arquivos de áudio em uma pasta.
+"""
+
+import os
+import sys
+import argparse
+import glob
+import torch
+import librosa
+import numpy as np
+from pathlib import Path
+from transformers import (
+    AutoFeatureExtractor, 
+    AutoModelForAudioClassification
+)
+import pandas as pd
+from collections import Counter
+import seaborn as sns
+from sklearn.metrics import confusion_matrix, classification_report, accuracy_score, f1_score
+
+def load_model(model_path):
+    """
+    Carrega o modelo treinado e o feature extractor.
+    """
+    print(f"Carregando modelo de: {model_path}")
+    
+    try:
+        feature_extractor = AutoFeatureExtractor.from_pretrained(model_path)
+        model = AutoModelForAudioClassification.from_pretrained(model_path)
+        
+        # Verificar se tem GPU disponível
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        model.to(device)
+        model.eval()
+        
+        print(f"Modelo carregado com sucesso! Usando device: {device}")
+        return model, feature_extractor, device
+        
+    except Exception as e:
+        print(f"Erro ao carregar modelo: {e}")
+        return None, None, None
+
+def load_audio(file_path, target_sampling_rate=16000):
+    """
+    Carrega um arquivo de áudio e redimensiona para a taxa de amostragem alvo.
+    """
+    try:
+        # Carregar áudio com librosa
+        audio, sr = librosa.load(file_path, sr=target_sampling_rate, mono=True)
+        return audio, sr
+    except Exception as e:
+        print(f"Erro ao carregar áudio {file_path}: {e}")
+        return None, None
+
+def predict_audio(model, feature_extractor, device, audio_path):
+    """
+    Classifica um único arquivo de áudio usando janela deslizante.
+    """
+    # Carregar áudio
+    audio, sr = load_audio(audio_path, feature_extractor.sampling_rate)
+    if audio is None:
+        return None, None, None, None
+    
+    try:
+        # Configurações da janela deslizante
+        window_size = int(sr * 5.0)  # Janela de 5 segundos
+        overlap = int(sr * 2.5)      # Sobreposição de 2.5 segundos (50%)
+        
+        # Se o áudio é menor que a janela, usar áudio completo
+        if len(audio) <= window_size:
+            predicted_label, confidence, class_id = predict_segment(
+                model, feature_extractor, device, audio, sr
+            )
+            return predicted_label, confidence, class_id, 1
+        
+        # Aplicar janela deslizante
+        predictions_list = []
+        confidences_list = []
+        
+        start = 0
+        segments_processed = 0
+        
+        while start < len(audio):
+            end = min(start + window_size, len(audio))
+            segment = audio[start:end]
+            
+            # Garantir que o segmento tenha tamanho mínimo (1 segundo)
+            if len(segment) >= sr:
+                pred_label, confidence, class_id = predict_segment(
+                    model, feature_extractor, device, segment, sr
+                )
+                if pred_label is not None:
+                    predictions_list.append(class_id)
+                    confidences_list.append(confidence)
+                    segments_processed += 1
+            
+            # Avançar janela
+            start += window_size - overlap
+            
+            # Se chegou no final, parar
+            if end == len(audio):
+                break
+        
+        if not predictions_list:
+            return None, None, None, 0
+        
+        # Combinar predições usando voto majoritário ponderado pela confiança
+        predicted_label, final_confidence, predicted_class_id = combine_predictions(
+            predictions_list, confidences_list
+        )
+        
+        return predicted_label, final_confidence, predicted_class_id, segments_processed
+        
+    except Exception as e:
+        print(f"Erro ao processar {audio_path}: {e}")
+        return None, None, None, 0
+
+def predict_segment(model, feature_extractor, device, audio_segment, sr):
+    """
+    Classifica um segmento individual de áudio.
+    """
+    try:
+        # Pré-processar segmento
+        inputs = feature_extractor(
+            audio_segment, 
+            sampling_rate=sr, 
+            max_length=int(sr * 5.0),
+            truncation=True,
+            padding=True,
+            return_tensors="pt"
+        )
+        
+        # Mover para device
+        inputs = {k: v.to(device) for k, v in inputs.items()}
+        
+        # Fazer predição
+        with torch.no_grad():
+            outputs = model(**inputs)
+            predictions = torch.nn.functional.softmax(outputs.logits, dim=-1)
+            predicted_class_id = predictions.argmax().item()
+            confidence = predictions.max().item()
+        
+        # Mapear para label
+        label_map = {0: "pt_br", 1: "pt_pt"}
+        predicted_label = label_map.get(predicted_class_id, "unknown")
+        
+        return predicted_label, confidence, predicted_class_id
+        
+    except Exception as e:
+        return None, None, None
+
+def combine_predictions(predictions_list, confidences_list):
+    """
+    Combina múltiplas predições usando voto majoritário ponderado pela confiança.
+    """
+    # Converter para arrays numpy
+    predictions = np.array(predictions_list)
+    confidences = np.array(confidences_list)
+    
+    # Calcular pontuações ponderadas para cada classe
+    class_scores = {}
+    for class_id in [0, 1]:  # pt_br=0, pt_pt=1
+        mask = predictions == class_id
+        if np.any(mask):
+            # Somar confiança de todas as predições desta classe
+            class_scores[class_id] = np.sum(confidences[mask])
+        else:
+            class_scores[class_id] = 0.0
+    
+    # Classe com maior pontuação
+    predicted_class_id = max(class_scores.keys(), key=lambda k: class_scores[k])
+    
+    # Confiança final: média das confiânças da classe vencedora
+    winner_mask = predictions == predicted_class_id
+    if np.any(winner_mask):
+        final_confidence = np.mean(confidences[winner_mask])
+    else:
+        final_confidence = 0.0
+    
+    # Mapear para label
+    label_map = {0: "pt_br", 1: "pt_pt"}
+    predicted_label = label_map.get(predicted_class_id, "unknown")
+    
+    return predicted_label, final_confidence, predicted_class_id
+
+def test_folder(model_path, audio_folder, output_file=None, supported_formats=None):
+    """
+    Testa todos os áudios em uma pasta usando janela deslizante.
+    """
+    if supported_formats is None:
+        supported_formats = ['.wav', '.mp3', '.flac', '.m4a', '.ogg']
+    
+    print(f"Testando áudios na pasta: {audio_folder}")
+    print("Usando janela deslizante de 5s com sobreposição de 2.5s para áudios longos")
+    
+    # Carregar modelo
+    model, feature_extractor, device = load_model(model_path)
+    if model is None:
+        return
+    
+    # Encontrar todos os arquivos de áudio
+    audio_files = []
+    for ext in supported_formats:
+        pattern = os.path.join(audio_folder, f"**/*{ext}")
+        audio_files.extend(glob.glob(pattern, recursive=True))
+    
+    if not audio_files:
+        print(f"Nenhum arquivo de áudio encontrado na pasta {audio_folder}")
+        print(f"Formatos suportados: {supported_formats}")
+        return
+    
+    print(f"Encontrados {len(audio_files)} arquivos de áudio")
+    
+    # Resultados
+    results = []
+    total_segments = 0
+    
+    # Processar cada arquivo
+    for i, audio_file in enumerate(audio_files, 1):
+        perc = (i / len(audio_files)) * 100
+        print(f"Processando {i}/{len(audio_files)} ({perc:.2f}%): {os.path.basename(audio_file)}")
+
+        # Classificar áudio com janela deslizante
+        predicted_label, confidence, class_id, segments_used = predict_audio(
+            model, feature_extractor, device, audio_file
+        )
+        
+        if predicted_label is not None:
+            # Calcular duração do áudio
+            try:
+                audio_duration = librosa.get_duration(filename=audio_file)
+            except:
+                audio_duration = None
+            
+            result = {
+                'arquivo': os.path.basename(audio_file),
+                'caminho_completo': audio_file,
+                'predição': predicted_label,
+                'confiança': confidence,
+                'classe_id': class_id,
+                'duração_segundos': audio_duration,
+                'segmentos_analisados': segments_used
+            }
+            results.append(result)
+            total_segments += segments_used
+            
+            # Mostrar resultado
+            if segments_used > 1:
+                print(f"  -> {predicted_label} (confiança: {confidence:.3f}) [{segments_used} segmentos]")
+            else:
+                print(f"  -> {predicted_label} (confiança: {confidence:.3f})")
+        else:
+            print(f"  -> Erro ao processar arquivo")
+    
+    # Criar DataFrame com resultados
+    if results:
+        df = pd.DataFrame(results)
+        
+        # Estatísticas
+        print(f"\n=== Resumo dos Resultados ===")
+        print(f"Total de arquivos processados: {len(results)}")
+        print(f"Arquivos com erro: {len(audio_files) - len(results)}")
+        print(f"Total de segmentos analisados: {total_segments}")
+        
+        # Estatísticas de segmentos
+        if 'segmentos_analisados' in df.columns:
+            avg_segments = df['segmentos_analisados'].mean()
+            max_segments = df['segmentos_analisados'].max()
+            multi_segment_files = len(df[df['segmentos_analisados'] > 1])
+            print(f"Segmentos por arquivo (média): {avg_segments:.1f}")
+            print(f"Máximo de segmentos: {max_segments}")
+            print(f"Arquivos com múltiplos segmentos: {multi_segment_files}")
+        
+        # Estatísticas de duração
+        if 'duração_segundos' in df.columns and df['duração_segundos'].notna().any():
+            avg_duration = df['duração_segundos'].mean()
+            max_duration = df['duração_segundos'].max()
+            print(f"Duração média dos áudios: {avg_duration:.1f}s")
+            print(f"Duração máxima: {max_duration:.1f}s")
+        
+        # Distribuição por classe
+        print(f"\nDistribuição das predições:")
+        distribution = Counter(df['predição'])
+        for label, count in distribution.items():
+            percentage = (count / len(results)) * 100
+            print(f"  {label}: {count} arquivos ({percentage:.1f}%)")
+        
+        # Confiança média
+        avg_confidence = df['confiança'].mean()
+        print(f"\nConfiança média: {avg_confidence:.3f}")
+        
+        # Arquivos com baixa confiança
+        low_confidence = df[df['confiança'] < 0.7]
+        if not low_confidence.empty:
+            print(f"\nArquivos com baixa confiança (< 0.7): {len(low_confidence)}")
+            for _, row in low_confidence.iterrows():
+                segments_info = f" [{row.get('segmentos_analisados', 1)} seg]" if row.get('segmentos_analisados', 1) > 1 else ""
+                print(f"  {row['arquivo']}: {row['predição']} ({row['confiança']:.3f}){segments_info}")
+        
+        # Salvar resultados se especificado
+        if output_file:
+            df.to_csv(output_file, index=False)
+            print(f"\nResultados salvos em: {output_file}")
+            
+            # Salvar também um arquivo de métricas se houver labels conhecidos para matrix de confusão
+            if results is not None and len([r for r in results if 'pt_br' in r.get('caminho_completo', '') or 'pt_pt' in r.get('caminho_completo', '')]) > 0:
+                metrics_file = output_file.replace('.csv', '_metrics.txt')
+                with open(metrics_file, 'w', encoding='utf-8') as f:
+                    f.write("=== MÉTRICAS DE CLASSIFICAÇÃO ===\n\n")
+                    f.write(f"Total de arquivos processados: {len(results)}\n")
+                    f.write(f"Confiança média: {avg_confidence:.3f}\n")
+                    f.write(f"Total de segmentos analisados: {total_segments}\n\n")
+                    f.write("Distribuição das predições:\n")
+                    for label, count in distribution.items():
+                        percentage = (count / len(results)) * 100
+                        f.write(f"  {label}: {count} arquivos ({percentage:.1f}%)\n")
+                print(f"Métricas básicas salvas em: {metrics_file}")
+        
+        return df
+    else:
+        print("Nenhum arquivo foi processado com sucesso.")
+        return None
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Testa classificação de sotaques em uma pasta de áudios"
+    )
+    parser.add_argument(
+        "audio_folder", 
+        help="Pasta contendo os arquivos de áudio para teste"
+    )
+    parser.add_argument(
+        "--model_path", 
+        default="./nn/results/final_model",
+        help="Caminho para o modelo treinado (default: ./nn/results/final_model)"
+    )
+    parser.add_argument(
+        "--output", 
+        help="Arquivo CSV para salvar os resultados (opcional)"
+    )
+    parser.add_argument(
+        "--formats", 
+        nargs="+",
+        default=['.wav', '.mp3', '.flac', '.m4a', '.ogg'],
+        help="Formatos de áudio suportados (default: .wav .mp3 .flac .m4a .ogg)"
+    )
+    
+    args = parser.parse_args()
+    
+    # Verificar se a pasta existe
+    if not os.path.exists(args.audio_folder):
+        print(f"Erro: Pasta '{args.audio_folder}' não encontrada!")
+        sys.exit(1)
+    
+    # Verificar se o modelo existe
+    if not os.path.exists(args.model_path):
+        print(f"Erro: Modelo '{args.model_path}' não encontrado!")
+        sys.exit(1)
+    
+    # Executar teste
+    results = test_folder(
+        model_path=args.model_path,
+        audio_folder=args.audio_folder,
+        output_file=args.output,
+        supported_formats=args.formats
+    )
+
+    # Plotar matriz de confusão se há resultados
+    if results is not None and not results.empty:
+        import matplotlib.pyplot as plt
+        
+        # Para matriz de confusão, precisamos de labels verdadeiros
+        # Vamos inferir do caminho completo do arquivo (não apenas do nome)
+        true_labels = []
+        pred_labels = results['predição'].tolist()
+        
+        for idx, row in results.iterrows():
+            arquivo = row['arquivo']
+            caminho_completo = row['caminho_completo']
+            
+            # Tentar inferir label do caminho completo (mais confiável)
+            if '/pt_br/' in caminho_completo or caminho_completo.endswith('/pt_br') or '\\pt_br\\' in caminho_completo or caminho_completo.endswith('\\pt_br'):
+                true_labels.append('pt_br')
+            elif '/pt_pt/' in caminho_completo or caminho_completo.endswith('/pt_pt') or '\\pt_pt\\' in caminho_completo or caminho_completo.endswith('\\pt_pt'):
+                true_labels.append('pt_pt')
+            # Fallback: tentar inferir do nome do arquivo
+            elif 'pt_br' in arquivo.lower() or 'brasil' in arquivo.lower():
+                true_labels.append('pt_br')
+            elif 'pt_pt' in arquivo.lower() or 'portugal' in arquivo.lower():
+                true_labels.append('pt_pt')
+            else:
+                # Se não conseguir inferir, marcar como desconhecido para não enviesar a matriz
+                true_labels.append('unknown')
+        
+        # Criar matriz de confusão apenas para arquivos com labels conhecidos
+        known_mask = [label != 'unknown' for label in true_labels]
+        known_true = [true_labels[i] for i in range(len(true_labels)) if known_mask[i]]
+        known_pred = [pred_labels[i] for i in range(len(pred_labels)) if known_mask[i]]
+        
+        if len(known_true) > 0:
+            labels = ['pt_br', 'pt_pt']
+            cm = confusion_matrix(known_true, known_pred, labels=labels)
+            
+            # Mostrar estatísticas
+            unknown_count = len(true_labels) - len(known_true)
+            accuracy = accuracy_score(known_true, known_pred)
+            f1_macro = f1_score(known_true, known_pred, labels=labels, average='macro')
+            f1_weighted = f1_score(known_true, known_pred, labels=labels, average='weighted')
+            f1_pt_br = f1_score(known_true, known_pred, labels=labels, pos_label='pt_br', average='binary') if 'pt_br' in labels else 0
+            f1_pt_pt = f1_score(known_true, known_pred, labels=labels, pos_label='pt_pt', average='binary') if 'pt_pt' in labels else 0
+            
+            print(f"\nEstatísticas da Matriz de Confusão:")
+            print(f"Arquivos com labels conhecidos: {len(known_true)}")
+            print(f"Arquivos com labels desconhecidos: {unknown_count}")
+            print(f"Acurácia: {accuracy:.3f} ({accuracy*100:.1f}%)")
+            print(f"F1-Score Macro: {f1_macro:.3f} ({f1_macro*100:.1f}%)")
+            print(f"F1-Score Ponderado: {f1_weighted:.3f} ({f1_weighted*100:.1f}%)")
+            print(f"F1-Score PT-BR: {f1_pt_br:.3f} ({f1_pt_br*100:.1f}%)")
+            print(f"F1-Score PT-PT: {f1_pt_pt:.3f} ({f1_pt_pt*100:.1f}%)")
+            
+            # Relatório de classificação detalhado
+            print(f"\nRelatório de Classificação:")
+            print(classification_report(known_true, known_pred, labels=labels, zero_division=0))
+            
+            if unknown_count > 0:
+                print(f"\nArquivos ignorados (sem label inferível):")
+                for i, (true_label, arquivo) in enumerate(zip(true_labels, results['arquivo'])):
+                    if true_label == 'unknown':
+                        print(f"  {arquivo}")
+            
+            # Mostrar erros de classificação
+            errors = []
+            for i, (true_label, pred_label, arquivo) in enumerate(zip(known_true, known_pred, 
+                                                                    [results.iloc[j]['arquivo'] for j in range(len(results)) if known_mask[j]])):
+                if true_label != pred_label:
+                    confidence = [results.iloc[j]['confiança'] for j in range(len(results)) if known_mask[j]][i]
+                    errors.append({
+                        'arquivo': arquivo,
+                        'verdadeiro': true_label,
+                        'predito': pred_label,
+                        'confianca': confidence
+                    })
+            
+            if errors:
+                print(f"\nErros de Classificação ({len(errors)} arquivos):")
+                for error in errors:
+                    print(f"  {error['arquivo']}: {error['verdadeiro']} → {error['predito']} (conf: {error['confianca']:.3f})")
+            else:
+                print(f"\n✓ Nenhum erro de classificação encontrado!")
+            
+            # Plotar
+            plt.figure(figsize=(8, 6))
+            sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', 
+                        xticklabels=labels, yticklabels=labels)
+            plt.title(f'Matriz de Confusão - Classificação de Sotaques\n({len(known_true)} arquivos, Acc: {accuracy:.1%}, F1-Macro: {f1_macro:.1%})')
+            plt.xlabel('Predição')
+            plt.ylabel('Verdadeiro')
+            plt.tight_layout()
+            
+            # Salvar figura
+            confusion_matrix_path = args.output.replace('.csv', '_confusion_matrix.png') if args.output else 'confusion_matrix.png'
+            plt.savefig(confusion_matrix_path, dpi=300, bbox_inches='tight')
+            print(f"\nMatriz de confusão salva em: {confusion_matrix_path}")
+            
+            # Salvar métricas detalhadas em arquivo
+            if args.output:
+                detailed_metrics_file = args.output.replace('.csv', '_detailed_metrics.txt')
+                with open(detailed_metrics_file, 'w', encoding='utf-8') as f:
+                    f.write("=== MÉTRICAS DETALHADAS DE CLASSIFICAÇÃO ===\n\n")
+                    f.write(f"Total de arquivos processados: {len(results)}\n")
+                    f.write(f"Arquivos com labels conhecidos: {len(known_true)}\n")
+                    f.write(f"Arquivos com labels desconhecidos: {unknown_count}\n")
+                    f.write(f"Total de segmentos analisados: {total_segments}\n\n")
+                    
+                    f.write("=== MÉTRICAS DE PERFORMANCE ===\n")
+                    f.write(f"Acurácia: {accuracy:.3f} ({accuracy*100:.1f}%)\n")
+                    f.write(f"F1-Score Macro: {f1_macro:.3f} ({f1_macro*100:.1f}%)\n")
+                    f.write(f"F1-Score Ponderado: {f1_weighted:.3f} ({f1_weighted*100:.1f}%)\n")
+                    f.write(f"F1-Score PT-BR: {f1_pt_br:.3f} ({f1_pt_br*100:.1f}%)\n")
+                    f.write(f"F1-Score PT-PT: {f1_pt_pt:.3f} ({f1_pt_pt*100:.1f}%)\n\n")
+                    
+                    f.write("=== RELATÓRIO DE CLASSIFICAÇÃO ===\n")
+                    f.write(classification_report(known_true, known_pred, labels=labels, zero_division=0))
+                    f.write("\n\n=== MATRIZ DE CONFUSÃO ===\n")
+                    f.write(f"      Predito\n")
+                    f.write(f"      pt_br  pt_pt\n")
+                    f.write(f"Real\n")
+                    f.write(f"pt_br  {cm[0][0]:4d}   {cm[0][1]:4d}\n")
+                    f.write(f"pt_pt  {cm[1][0]:4d}   {cm[1][1]:4d}\n\n")
+                    
+                    if errors:
+                        f.write(f"=== ERROS DE CLASSIFICAÇÃO ({len(errors)} arquivos) ===\n")
+                        for error in errors:
+                            f.write(f"{error['arquivo']}: {error['verdadeiro']} → {error['predito']} (conf: {error['confianca']:.3f})\n")
+                    else:
+                        f.write("=== ERROS DE CLASSIFICAÇÃO ===\n")
+                        f.write("Nenhum erro de classificação encontrado!\n")
+                
+                print(f"Métricas detalhadas salvas em: {detailed_metrics_file}")
+            
+            plt.show()
+        else:
+            print(f"\n⚠️  Não foi possível criar matriz de confusão:")
+            print(f"Nenhum arquivo tinha label inferível do caminho ou nome.")
+            print(f"Para usar a matriz de confusão, organize os arquivos em pastas 'pt_br' e 'pt_pt'")
+            print(f"ou garanta que os nomes dos arquivos contenham essas strings.")
+
+if __name__ == "__main__":
+    # Exemplos de uso no código para referência
+    if len(sys.argv) == 1:
+        print("=== Script de Teste de Classificação de Sotaques ===")
+        print()
+        print("Este script testa um modelo treinado em uma pasta de áudios usando janela deslizante.")
+        print()
+        print("Uso:")
+        print("  python test_audio_folder.py <pasta_de_audios>")
+        print()
+        print("Exemplos:")
+        print("  python test_audio_folder.py ./audios_teste")
+        print("  python test_audio_folder.py ./audios_teste --output resultados.csv")
+        print("  python test_audio_folder.py ./audios_teste --model_path ./results/checkpoint-20000")
+        print()
+        print("Parâmetros:")
+        print("  pasta_de_audios  : Pasta com arquivos de áudio para classificar")
+        print("  --model_path     : Caminho do modelo treinado (default: ./results/final_model)")
+        print("  --output         : Arquivo CSV para salvar resultados (opcional)")
+        print("  --formats        : Formatos suportados (default: .wav .mp3 .flac .m4a .ogg)")
+        print()
+        print("Funcionalidades da Janela Deslizante:")
+        print("- Janelas de 5 segundos com sobreposição de 2.5s")
+        print("- Áudios curtos: classificação direta")
+        print("- Áudios longos: múltiplos segmentos combinados")
+        print("- Resultado final: voto majoritário ponderado por confiança")
+        print()
+        print("O script irá:")
+        print("1. Carregar o modelo treinado")
+        print("2. Encontrar todos os arquivos de áudio na pasta")
+        print("3. Classificar cada áudio usando janela deslizante")
+        print("4. Mostrar estatísticas detalhadas dos resultados")
+        print("5. Salvar resultados em CSV (se especificado)")
+        print("6. Gerar matriz de confusão (se possível inferir labels)")
+        sys.exit(0)
+    
+    main()

train.py

@@ -0,0 +1,192 @@
+import os
+import torch
+import glob
+from datasets import load_dataset, Audio, Dataset, ClassLabel
+from transformers import (
+    AutoFeatureExtractor,
+    AutoModelForAudioClassification,
+    TrainingArguments,
+    Trainer
+)
+import numpy as np
+import evaluate
+import random
+
+# --- Configurações ---
+# Modelo base do Hugging Face. XLSR-53 é uma ótima escolha multilíngue.
+MODEL_NAME = "lgris/w2v_podcasts_base_400k_pt"
+# Pasta onde os dados pré-processados foram salvos
+DATASET_PATH = "./dataset_preparado/"
+# Pasta para salvar o modelo treinado e os logs
+OUTPUT_DIR = "./portuguese-accent-classifier"
+# Hiperparâmetros de treinamento
+NUM_TRAIN_EPOCHS = 50
+BATCH_SIZE = 32 # Reduza se tiver problemas de memória na GPU
+
+def train_model():
+    """
+    Carrega o dataset, pré-processa os dados e faz o fine-tuning do modelo
+    para classificação de sotaques.
+    """
+    print("Carregando dataset a partir das pastas...")
+    
+    # Carregar todos os arquivos manualmente para contornar limitação do audiofolder
+    pt_br_files = glob.glob(os.path.join(DATASET_PATH, "pt_br", "*.wav"))
+    pt_pt_files = glob.glob(os.path.join(DATASET_PATH, "pt_pt", "*.wav"))
+    
+    print(f"Arquivos pt_br encontrados: {len(pt_br_files)}")
+    print(f"Arquivos pt_pt encontrados: {len(pt_pt_files)}")
+    
+    # Criar listas de arquivos e labels
+    all_files = []
+    all_labels = []
+    
+    # Adicionar arquivos pt_br com label 0
+    for file_path in pt_br_files:
+        all_files.append(file_path)
+        all_labels.append(0)
+        
+    # Adicionar arquivos pt_pt com label 1  
+    for file_path in pt_pt_files:
+        all_files.append(file_path)
+        all_labels.append(1)
+    
+    print(f"Total de arquivos carregados: {len(all_files)}")
+    
+    # Criar dataset customizado
+    data_dict = {
+        "audio": all_files,
+        "label": all_labels
+    }
+    
+    dataset = Dataset.from_dict(data_dict)
+    dataset = dataset.cast_column("audio", Audio())
+    
+    # Configurar labels como ClassLabel para permitir estratificação
+    labels = ["pt_br", "pt_pt"]
+    dataset = dataset.cast_column("label", ClassLabel(names=labels))
+    
+    print(f"Dataset criado com {len(dataset)} exemplos")
+    
+    # Dividir em treino e teste
+    dataset = dataset.train_test_split(test_size=0.1, shuffle=True, stratify_by_column="label")
+
+    print("Dataset carregado e dividido:")
+    print(dataset)
+    
+    # Criar mapeamento de labels
+    label2id, id2label = {}, {}
+    for i, label in enumerate(labels):
+        label2id[label] = str(i)
+        id2label[str(i)] = label
+
+    print(f"Mapeamento de labels: {id2label}")
+
+    # Carregar o Feature Extractor
+    feature_extractor = AutoFeatureExtractor.from_pretrained(MODEL_NAME)
+    target_sampling_rate = feature_extractor.sampling_rate
+    target_length = int(target_sampling_rate * 5.0)  # 5 segundos em samples
+    
+    def preprocess_function(examples):
+        # O dataset já foi resampleado, mas garantimos aqui
+        # A função Audio() do 'datasets' carrega o áudio
+        audio_arrays = [x["array"] for x in examples["audio"]]
+        
+        # Processar cada áudio individualmente para truncamento/padding aleatório
+        processed_audios = []
+        for audio_array in audio_arrays:
+            audio_length = len(audio_array)
+            
+            if audio_length > target_length:
+                # Áudio maior que 5s: truncar aleatoriamente
+                start_idx = random.randint(0, audio_length - target_length)
+                processed_audio = audio_array[start_idx:start_idx + target_length]
+            else:
+                # Áudio menor que 5s: adicionar silêncio aleatoriamente
+                padding_needed = target_length - audio_length
+                
+                # Distribuir o padding aleatoriamente entre início e fim
+                left_padding = random.randint(0, padding_needed)
+                right_padding = padding_needed - left_padding
+                
+                # Criar arrays de silêncio (zeros)
+                left_silence = np.zeros(left_padding, dtype=audio_array.dtype)
+                right_silence = np.zeros(right_padding, dtype=audio_array.dtype)
+                
+                # Concatenar: silêncio_esquerdo + áudio + silêncio_direito
+                processed_audio = np.concatenate([left_silence, audio_array, right_silence])
+            
+            processed_audios.append(processed_audio)
+        
+        # Usar o feature_extractor com os áudios já processados
+        inputs = feature_extractor(
+            processed_audios, 
+            sampling_rate=target_sampling_rate, 
+            padding=False,  # Não precisamos de padding adicional
+            truncation=False  # Não precisamos de truncamento adicional
+        )
+        return inputs
+
+    # Aplicar o pré-processamento ao dataset
+    print("Aplicando pré-processamento...")
+    encoded_dataset = dataset.map(preprocess_function, remove_columns="audio", batched=True)
+    
+    # Carregar o Modelo
+    num_labels = len(labels)
+    model = AutoModelForAudioClassification.from_pretrained(
+        MODEL_NAME,
+        num_labels=num_labels,
+        label2id={k: int(v) for k, v in label2id.items()}, # Convertendo keys de str para int
+        id2label=id2label,
+        ignore_mismatched_sizes=True # Permite substituir a 'cabeça' de classificação
+    )
+    
+    # Métrica de avaliação
+    accuracy = evaluate.load("accuracy")
+    def compute_metrics(eval_pred):
+        predictions = np.argmax(eval_pred.predictions, axis=1)
+        return accuracy.compute(predictions=predictions, references=eval_pred.label_ids)
+
+    # Argumentos de Treinamento
+    training_args = TrainingArguments(
+        output_dir=OUTPUT_DIR,
+        eval_strategy="epoch",  # Adicionado para compatibilidade com load_best_model_at_end
+        save_strategy="epoch",
+        learning_rate=3e-5,
+        per_device_train_batch_size=BATCH_SIZE,
+        per_device_eval_batch_size=BATCH_SIZE,
+        num_train_epochs=NUM_TRAIN_EPOCHS,
+        weight_decay=0.01,
+        logging_steps=10,
+        load_best_model_at_end=True,
+        metric_for_best_model="accuracy",
+        report_to="tensorboard",
+        push_to_hub=False,
+    )
+
+    # Inicializar o Trainer
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        train_dataset=encoded_dataset["train"],
+        eval_dataset=encoded_dataset["test"],
+        tokenizer=feature_extractor,
+        compute_metrics=compute_metrics,
+    )
+
+    # Iniciar o Treinamento
+    print("\n--- Iniciando o Fine-tuning ---")
+    trainer.train()
+    print("--- Treinamento Concluído ---\n")
+    
+    # Salvar o modelo final
+    final_model_path = os.path.join(OUTPUT_DIR, "final_model")
+    trainer.save_model(final_model_path)
+    print(f"Modelo final salvo em: {final_model_path}")
+
+
+if __name__ == '__main__':
+    # Garante que o treinamento use GPU se disponível
+    if not torch.cuda.is_available():
+        print("Aviso: Nenhuma GPU encontrada. O treinamento será muito lento.")
+    train_model()

training_args.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8ad21406f7ae2dc27d3daf024fa3f33654987214d214e74d138e8c8a60b3182b
+size 5777