Cleanup: Repositório otimizado (código + dashboard apenas)

.dockerignore

@@ -0,0 +1,12 @@
+# Ignorar pastas densas que já estão no repo local
+venv/
+.venv/
+__pycache__/
+.tmp/
+.git/
+.env
+
+# Outros
+*.wav
+*.mp3
+*.log

.gitattributes

@@ -0,0 +1,7 @@
+*.wav filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+local_finetuned_model/model.safetensors filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+logo_base64.txt filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,33 @@
+# Venv
+venv/
+.venv/
+env/
+
+# Python caching
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Temporary files
+.tmp/
+*.wav
+*.mp3
+*.png
+*.jpg
+*.jpeg
+
+# Environments
+.env
+.flaskenv
+
+# Models
+local_finetuned_model/
+*.safetensors
+*.bin
+*.h5
+*.pt
+*.onnx
+
+# OS
+.DS_Store
+Thumbs.db

.vercelignore

@@ -0,0 +1,12 @@
+# Ignora arquivos de backend e ML para o Vercel não tentar buildar Python
+execution/
+directives/
+requirements.txt
+Dockerfile
+Procfile
+main.py
+venv/
+.tmp/
+.env
+# Ignora caches
+__pycache__/

ConfereAI_FastTrain_Colab.ipynb

@@ -0,0 +1,189 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "gpuType": "T4"
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "header"
+      },
+      "source": [
+        "# 🚀 ConfereAI - Fast Training (GPU Edition)\n",
+        "Este notebook permite treinar o motor neural do ConfereAI utilizando a GPU gratuita do Google Colab. \n",
+        "\n",
+        "**Instruções:**\n",
+        "1. Vá em `Ambiente de Execução` > `Alterar tipo de ambiente` e selecione **T4 GPU**.\n",
+        "2. Preencha as configurações abaixo.\n",
+        "3. Execute as células em ordem."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "setup"
+      },
+      "outputs": [],
+      "source": [
+        "# @title 1. Instalar Dependências\n",
+        "!pip install -q transformers[torch] librosa soundfile huggingface_hub accelerate"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "config"
+      },
+      "outputs": [],
+      "source": [
+        "# @title 2. Configurações do Hugging Face\n",
+        "HF_TOKEN = \"\" # @param {type:\"string\"}\n",
+        "REPO_ID = \"TEDDyx86/confereai-dev\" # @param {type:\"string\"}\n",
+        "BRANCH = \"main\" # @param {type:\"string\"}\n",
+        "\n",
+        "from huggingface_hub import HfApi, login\n",
+        "if HF_TOKEN:\n",
+        "    login(token=HF_TOKEN)\n",
+        "else:\n",
+        "    print(\"❌ Por favor, insira o seu HF_TOKEN!\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "upload"
+      },
+      "outputs": [],
+      "source": [
+        "# @title 3. Upload do Dataset (.zip)\n",
+        "from google.colab import files\n",
+        "import zipfile\n",
+        "import os\n",
+        "import shutil\n",
+        "\n",
+        "uploaded = files.upload()\n",
+        "dataset_zip = list(uploaded.keys())[0]\n",
+        "\n",
+        "DATASET_DIR = \"dataset_training\"\n",
+        "if os.path.exists(DATASET_DIR): shutil.rmtree(DATASET_DIR)\n",
+        "os.makedirs(DATASET_DIR)\n",
+        "\n",
+        "with zipfile.ZipFile(dataset_zip, 'r') as zip_ref:\n",
+        "    zip_ref.extractall(DATASET_DIR)\n",
+        "\n",
+        "print(f\"✅ Dataset extraído em: {DATASET_DIR}\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "training"
+      },
+      "outputs": [],
+      "source": [
+        "# @title 4. Executar Treinamento (Fine-Tuning)\n",
+        "import torch\n",
+        "from torch.utils.data import Dataset\n",
+        "from transformers import Wav2Vec2FeatureExtractor, Wav2Vec2ForSequenceClassification, Trainer, TrainingArguments\n",
+        "import librosa\n",
+        "\n",
+        "BASE_MODEL = \"HyperMoon/wav2vec2-base-960h-finetuned-deepfake\"\n",
+        "OUTPUT_DIR = \"local_finetuned_model\"\n",
+        "\n",
+        "class DeepfakeDataset(Dataset):\n",
+        "    def __init__(self, root_dir, processor):\n",
+        "        self.files = []\n",
+        "        self.processor = processor\n",
+        "        for label, folder in enumerate(['real', 'fake']):\n",
+        "            path = os.path.join(root_dir, folder)\n",
+        "            if os.path.exists(path):\n",
+        "                for f in os.listdir(path):\n",
+        "                    if f.endswith(('.wav', '.mp3', '.flac')):\n",
+        "                        self.files.append({\"path\": os.path.join(path, f), \"label\": label})\n",
+        "\n",
+        "    def __len__(self): return len(self.files)\n",
+        "    def __getitem__(self, idx):\n",
+        "        item = self.files[idx]\n",
+        "        speech, _ = librosa.load(item[\"path\"], sr=16000)\n",
+        "        input_values = self.processor(speech, sampling_rate=16000, return_tensors=\"pt\", padding=\"max_length\", max_length=160000, truncation=True).input_values[0]\n",
+        "        return {\"input_values\": input_values, \"labels\": torch.tensor(item[\"label\"], dtype=torch.long)}\n",
+        "\n",
+        "processor = Wav2Vec2FeatureExtractor.from_pretrained(BASE_MODEL)\n",
+        "model = Wav2Vec2ForSequenceClassification.from_pretrained(BASE_MODEL, num_labels=2, ignore_mismatched_sizes=True)\n",
+        "\n",
+        "# Congelar base para focar no aprendizado das novas fraudes (Lógica Robusta)\n",
+        "if hasattr(model, 'freeze_feature_extractor'):\n",
+        "    model.freeze_feature_extractor()\n",
+        "elif hasattr(model, 'freeze_feature_encoder'):\n",
+        "    model.freeze_feature_encoder()\n",
+        "\n",
+        "if hasattr(model, 'wav2vec2'):\n",
+        "    for param in model.wav2vec2.parameters(): param.requires_grad = False\n",
+        "\n",
+        "training_args = TrainingArguments(\n",
+        "    output_dir=\"./results\",\n",
+        "    num_train_epochs=5,\n",
+        "    per_device_train_batch_size=4,\n",
+        "    gradient_accumulation_steps=2,\n",
+        "    learning_rate=2e-5,\n",
+        "    logging_steps=1,\n",
+        "    push_to_hub=False,\n",
+        "    report_to=\"none\"\n",
+        ")\n",
+        "\n",
+        "trainer = Trainer(\n",
+        "    model=model,\n",
+        "    args=training_args,\n",
+        "    train_dataset=DeepfakeDataset(DATASET_DIR, processor)\n",
+        ")\n",
+        "\n",
+        "print(\"🚀 Iniciando treinamento na GPU...\")\n",
+        "trainer.train()\n",
+        "\n",
+        "model.save_pretrained(OUTPUT_DIR)\n",
+        "processor.save_pretrained(OUTPUT_DIR)\n",
+        "print(f\"✅ Treinamento concluído. Modelo salvo em {OUTPUT_DIR}\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "push"
+      },
+      "outputs": [],
+      "source": [
+        "# @title 5. Sincronizar com Hugging Face Space\n",
+        "api = HfApi()\n",
+        "print(f\"📦 Subindo modelo para {REPO_ID}...\")\n",
+        "\n",
+        "api.upload_folder(\n",
+        "    folder_path=OUTPUT_DIR,\n",
+        "    path_in_repo=OUTPUT_DIR,\n",
+        "    repo_id=REPO_ID,\n",
+        "    repo_type=\"space\",\n",
+        "    token=HF_TOKEN,\n",
+        "    commit_message=\"🤖 Auto-Update: Novo modelo treinado via Google Colab\"\n",
+        ")\n",
+        "\n",
+        "print(\"✨ Sucesso! O seu Space irá reiniciar em breve com o novo modelo.\")"
+      ]
+    }
+  ]
+}

Dockerfile

@@ -0,0 +1,26 @@
+FROM python:3.10-slim
+
+# Instala dependências do sistema
+RUN apt-get update && apt-get install -y \
+    libsndfile1 \
+    ffmpeg \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+# Copia arquivos de requisitos
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copia o resto do código
+COPY . .
+
+# Garante que a pasta .tmp existe e tem permissão
+RUN mkdir -p .tmp && chmod 777 .tmp
+
+# Porta padrão do Hugging Face Spaces
+ENV PORT=7860
+EXPOSE 7860
+
+# Comando para iniciar o servidor
+CMD ["python", "main.py"]

README.md

@@ -0,0 +1,58 @@
+---
+title: ConfereAI - Audio Fraud Detection (V2.2)
+emoji: 🛡️
+colorFrom: purple
+colorTo: indigo
+sdk: docker
+app_port: 7860
+pinned: true
+---
+
+# 🛡️ CONFEREAI 
+### *Verdade na voz, integridade no som.*
+
+O **ConfereAI** é uma plataforma de segurança cibernética de última geração projetada para identificar e neutralizar fraudes de áudio, deepfakes e vozes clonadas via Inteligência Artificial. Utilizando uma arquitetura de redes neurais profundas, o sistema analisa micro-imperfeições acústicas imperceptíveis ao ouvido humano.
+
+![ConfereAI Dashboard](dashboard/assets/logo.png)
+
+## 🚀 Diferenciais Tecnológicos
+
+- **🧠 Motor Neural Local**: Diferente de soluções que dependem de APIs instáveis, o ConfereAI utiliza um motor dedicado baseado em **Wav2Vec 2.0** (HyperMoon) rodando localmente no servidor.
+- **📊 Evidência Espectral**: Gera espectrogramas de Mel em tempo real, permitindo uma análise forense visual das frequências de áudio.
+- **⚡ Resposta Instantânea**: Análise completa em segundos, ideal para validação de identidade e prevenção de fraudes em tempo real.
+- **💎 Interface Onyx**: Dashboard premium com Estética Onyx e Glassmorphism, focado em clareza e experiência do usuário (UX).
+
+## 🛠️ Arquitetura de Software
+
+O sistema é dividido em duas camadas principais:
+
+1. **Backend (Python/FastAPI)**: 
+   - Gerenciamento de arquivos e processamento paralelo.
+   - Extração de características com `Librosa`.
+   - Inferência neural via `PyTorch` e `Transformers`.
+2. **Frontend (Vanilla JS/CSS)**:
+   - Interface ultra-responsiva sem dependências pesadas.
+   - Visualização dinâmica de resultados e medidores de confiança neon.
+
+## 🔬 O Coração da IA: HyperMoon Engine
+
+Utilizamos o modelo **HyperMoon/wav2vec2-base-960h-finetuned-deepfake**, treinado com o dataset acadêmico **ASVspoof**. 
+- **Foco**: Detecção de descontinuidades rítmicas e artefatos de compressão típicos de IAs generativas.
+- **Veredito**: Entrega um score de probabilidade (0% a 100%) e um veredito direto: **AUTÊNTICO** ou **FRAUDE DETECTADA**.
+
+## 📦 Como Rodar o Projeto
+
+### Localmente (Docker)
+```bash
+docker build -t confereai .
+docker run -p 7860:7860 confereai
+```
+
+### Deploy no Hugging Face Spaces
+1. Crie um novo **Space** no Hugging Face.
+2. Selecione o SDK: **Docker**.
+3. Faça o push deste repositório.
+4. O sistema irá buildar e servir automaticamente na porta 7860.
+
+---
+**CONFEREAI** - *Protegendo a integridade da comunicação humana na era da IA.*

agent.md

@@ -0,0 +1,21 @@
+# Diretrizes do Agente IA (Antigravity)
+
+Ao trabalhar neste projeto (ConfereAI), você (a IA) DEVE obrigatoriamente referenciar e seguir as diretrizes/metodologias listadas na pasta `superpowers/skills` conforme o contexto da tarefa em mãos.
+
+Sempre que o Humano solicitar uma alteração ou criação, verifique qual skill se aplica e aja rigorosamente de acordo com ela:
+
+## 1. Regra Geral de Inicialização
+- NUNCA comece a escrever código ou desenhar componentes para uma nova feature sem antes consultar e executar o processo iterativo definido em `superpowers/skills/brainstorming/SKILL.md`. O Humano deve aprovar a ideia antes do código nascer.
+
+## 2. Para Tarefas de Machine Learning (Motor)
+- A precisão matemática é inegociável. Para qualquer script de processamento de dados, manipulação de tensores ou modelo em si, leia e aplique OBRIGATORIAMENTE o fluxo de `superpowers/skills/test-driven-development/SKILL.md`.
+- Se o Humano relatar anomalias no treinamento (loss não cai, acurácia baixa) ou na inferência, NÃO altere nada sem antes invocar o `superpowers/skills/systematic-debugging/SKILL.md` para isolar a causa-raiz cientificamente.
+- Quando uma etapa crucial do modelo for finalizada, exija as provas estabelecidas em `superpowers/skills/verification-before-completion/SKILL.md`.
+
+## 3. Para Tarefas de Frontend (Dashboard UI/UX)
+- Antes de alterar layouts, reescrever CSS ou criar novos componentes globais, execute os passos em `superpowers/skills/writing-plans/SKILL.md`. Mostre o plano (passo a passo de 2 a 5 minutos) ao Humano e espere aprovação.
+- Se a refatoração for de alto impacto, siga o `superpowers/skills/using-git-worktrees/SKILL.md` para criar um ambiente isolado de testes que proteja o dashboard atual.
+- Para manter a harmonia do Design System, crie o hábito de acionar o `superpowers/skills/requesting-code-review/SKILL.md` ao final de cada etapa visual, passando a bola para o Humano aprovar a usabilidade.
+
+---
+**Nota para o Agente:** Este arquivo é a sua espinha dorsal neste repositório. Confie nas metodologias do diretório *superpowers/skills* em detrimento de abordagens mais fáceis e desestruturadas.

dashboard/admin.html

@@ -0,0 +1,139 @@
+<!DOCTYPE html>
+<html lang="pt-BR">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>ConfereAI Admin | Fine-Tuning</title>
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&family=Outfit:wght@700;900&display=swap" rel="stylesheet">
+    <link rel="stylesheet" href="style.css">
+    <style>
+        .hidden { display: none !important; }
+        
+        /* Admin specific styles */
+        .admin-container {
+            max-width: 600px;
+            margin: 0 auto;
+        }
+        
+        .form-group {
+            margin-bottom: 1.5rem;
+            text-align: left;
+        }
+        
+        .form-group label {
+            display: block;
+            margin-bottom: 0.5rem;
+            color: var(--text-secondary);
+        }
+        
+        .form-control {
+            width: 100%;
+            padding: 1rem;
+            background: rgba(0,0,0,0.3);
+            border: 1px solid var(--glass-border);
+            border-radius: 8px;
+            color: white;
+            font-family: 'Inter', sans-serif;
+            transition: border-color 0.3s;
+        }
+        
+        .form-control:focus {
+            outline: none;
+            border-color: var(--accent);
+        }
+
+        .progress-bar-container {
+            width: 100%;
+            height: 20px;
+            background: rgba(0,0,0,0.3);
+            border-radius: 10px;
+            overflow: hidden;
+            margin-top: 1rem;
+            border: 1px solid var(--glass-border);
+        }
+
+        .progress-bar {
+            height: 100%;
+            background: linear-gradient(90deg, var(--primary), var(--cyan));
+            width: 0%;
+            transition: width 0.5s ease-in-out;
+        }
+
+        .status-text {
+            margin-top: 1rem;
+            font-size: 0.9rem;
+            color: var(--text-secondary);
+        }
+    </style>
+</head>
+<body>
+    <div class="aurora-mesh"></div>
+
+    <nav>
+        <div class="logo">
+            <a href="index.html" style="text-decoration: none; display: flex; align-items: center; gap: 12px;">
+                <span>Confere<span class="vibrance">AI</span> Admin</span>
+            </a>
+        </div>
+        <div class="nav-links">
+            <a href="index.html">Voltar ao App</a>
+        </div>
+    </nav>
+
+    <main>
+        <!-- Login Section -->
+        <section id="login-section" class="admin-container">
+            <div class="glass-card" style="text-align: center;">
+                <h2 style="font-family: 'Outfit'; font-size: 2rem; margin-bottom: 1rem;">Acesso Restrito</h2>
+                <p style="color: var(--text-secondary); margin-bottom: 2rem;">Insira a senha de administrador para gerenciar o aprendizado do motor neural.</p>
+                
+                <form id="login-form">
+                    <div class="form-group">
+                        <input type="password" id="admin-password" class="form-control" placeholder="Senha do Admin" required>
+                    </div>
+                    <button type="submit" class="btn-primary" style="width: 100%;">Entrar</button>
+                </form>
+                <div id="login-error" class="status-text hidden" style="color: var(--danger);">Senha incorreta.</div>
+            </div>
+        </section>
+
+        <!-- Dashboard Section -->
+        <section id="dashboard-section" class="admin-container hidden">
+            <div class="glass-card" style="text-align: center;">
+                <h2 style="font-family: 'Outfit'; font-size: 2rem; margin-bottom: 1rem;">Treinar Modelo</h2>
+                <p style="color: var(--text-secondary); margin-bottom: 2rem;">Faça upload de um arquivo .zip ou .rar contendo pastas 'real' e 'fake' com áudios (.mp3, .wav, .flac).</p>
+                
+                <div id="drop-zone" style="padding: 3rem; border-radius: 12px; margin-bottom: 2rem;">
+                    <div class="upload-icon">
+                        <svg width="48" height="48" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+                            <path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"></path>
+                            <polyline points="17 8 12 3 7 8"></polyline>
+                            <line x1="12" y1="3" x2="12" y2="15"></line>
+                        </svg>
+                    </div>
+                    <h3 style="margin-bottom: 10px;">Arraste o arquivo ou clique</h3>
+                    <p style="color: var(--text-secondary); font-size: 0.9rem;">Limite: 50MB (max 5 arquivos recomendados por lote)</p>
+                    <input type="file" id="file-input" class="hidden" accept=".zip,.rar">
+                </div>
+
+                <div id="selected-file-info" class="hidden" style="margin-bottom: 1.5rem; color: var(--success); font-weight: 500;">
+                    Arquivo selecionado: <span id="filename-display"></span>
+                </div>
+
+                <button id="btn-upload-train" class="btn-primary" style="width: 100%;" disabled>Iniciar Upload e Treinamento</button>
+
+                <!-- Training Progress -->
+                <div id="training-progress-container" class="hidden" style="margin-top: 2rem;">
+                    <h4 style="color: var(--cyan);">Status do Treinamento</h4>
+                    <div class="progress-bar-container">
+                        <div id="training-progress-bar" class="progress-bar"></div>
+                    </div>
+                    <div id="training-status-text" class="status-text">Preparando ambiente...</div>
+                </div>
+            </div>
+        </section>
+    </main>
+
+    <script src="js/admin.js"></script>
+</body>
+</html>

dashboard/app.js

@@ -0,0 +1,213 @@
+const dropZone = document.getElementById('drop-zone');
+const audioInput = document.getElementById('audio-input');
+const selectBtn = document.getElementById('select-file-btn');
+const resultsSection = document.getElementById('results-section');
+const verdictText = document.getElementById('verdict-text');
+const confidenceValue = document.getElementById('confidence-value');
+const confidencePath = document.getElementById('confidence-path');
+const specContainer = document.getElementById('spec-container');
+const verdictExplanation = document.getElementById('verdict-explanation');
+
+// Event Listeners
+selectBtn.addEventListener('click', () => audioInput.click());
+
+audioInput.addEventListener('change', (e) => {
+    if (e.target.files.length) handleUpload(e.target.files[0]);
+});
+
+dropZone.addEventListener('dragover', (e) => {
+    e.preventDefault();
+    dropZone.classList.add('dragover');
+});
+
+dropZone.addEventListener('dragleave', () => {
+    dropZone.classList.remove('dragover');
+});
+
+dropZone.addEventListener('drop', (e) => {
+    e.preventDefault();
+    dropZone.classList.remove('dragover');
+    if (e.dataTransfer.files.length) handleUpload(e.dataTransfer.files[0]);
+});
+
+async function handleUpload(file) {
+    // Detecta se estamos rodando localmente ou no Hugging Face
+    const isLocal = window.location.hostname === 'localhost' || window.location.hostname === '127.0.0.1';
+    
+    // Se você estiver no Vercel, mude '' para a URL do seu Space no Hugging Face
+    const API_URL = ''; // Usa o host atual (mesma porta)
+    // Reset e mostra seção de resultados
+    resultsSection.style.display = 'grid';
+    verdictText.textContent = 'PROCESSANDO...';
+    if (verdictExplanation) verdictExplanation.textContent = '';
+    confidenceValue.textContent = '0%';
+    confidencePath.setAttribute('stroke-dasharray', '0, 100');
+    specContainer.innerHTML = '<p>Analisando frequências...</p>';
+
+    const formData = new FormData();
+    formData.append('file', file);
+
+    try {
+        const response = await fetch(`${API_URL}/analyze`, {
+            method: 'POST',
+            body: formData
+        });
+
+        const data = await response.json();
+        displayResults(data);
+    } catch (error) {
+        console.error('Erro na análise:', error);
+        verdictText.innerText = 'ERRO NA CONEXÃO';
+    }
+}
+
+function displayResults(data) {
+    console.log('Resultados recebidos:', data);
+    
+    // Atualiza veredito
+    const isSpoof = data.verdict === 'SPOOF';
+    verdictText.textContent = isSpoof ? ' FRAUDE DETECTADA' : ' ÁUDIO AUTÊNTICO';
+    verdictText.style.color = isSpoof ? '#EF4444' : '#10B981';
+
+    // Atualiza explicação do veredito (Consenso dos Motores)
+    /* 
+    if (verdictExplanation) {
+        verdictExplanation.textContent = data.engines_consensus || '';
+        verdictExplanation.style.color = isSpoof ? '#FCA5A5' : '#6EE7B7';
+    }
+    */
+    verdictText.style.color = isSpoof ? '#EF4444' : '#10B981';
+    
+    // Atualiza ponto de pulso
+    const pulseDot = document.querySelector('.pulse');
+    if (pulseDot) {
+        pulseDot.style.background = isSpoof ? '#EF4444' : '#10B981';
+        pulseDot.style.boxShadow = `0 0 10px ${isSpoof ? '#EF4444' : '#10B981'}`;
+    }
+    
+    // Agora mostramos a PROBABILIDADE DE FRAUDE no círculo, pois é o que importa para o usuário
+    const fraudProb = Math.round((data.fraud_score || 0) * 100);
+    console.log('Calculated Fraud Prob:', fraudProb);
+    
+    if (confidenceValue) {
+        confidenceValue.textContent = `${fraudProb}%`;
+    }
+    
+    if (confidencePath) {
+        // Cor do círculo baseada no risco
+        if (fraudProb > 80) {
+            confidencePath.style.stroke = '#EF4444'; // Vermelho (Perigo)
+            if (pulseDot) pulseDot.style.background = '#EF4444';
+        } else if (fraudProb > 40) {
+            confidencePath.style.stroke = '#F59E0B'; // Amarelo (Atenção)
+            if (pulseDot) pulseDot.style.background = '#F59E0B';
+        } else {
+            confidencePath.style.stroke = '#10B981'; // Verde (Seguro)
+            if (pulseDot) pulseDot.style.background = '#10B981';
+        }
+
+        // Animação do círculo
+        confidencePath.setAttribute('stroke-dasharray', `${fraudProb}, 100`);
+    }
+    // Atualiza Espectrograma
+    // Atualiza Espectrograma e Heatmap (XAI)
+    if (data.spectrogram_url) {
+        const specName = data.spectrogram_url.split(/[\\/]/).pop();
+        const timestamp = new Date().getTime();
+        
+        let heatmapHtml = '<div class="heatmap-overlay">';
+        if (data.temporal_scores && data.temporal_scores.length > 0) {
+            data.temporal_scores.forEach(score => {
+                // Interpola cor entre verde (seguro) e vermelho (fraude)
+                // Usando HSL: 120 (verde) a 0 (vermelho)
+                const hue = 120 - (score * 120);
+                const opacity = score > 0.4 ? (score * 0.7) : (score * 0.2); 
+                heatmapHtml += `<div class="heatmap-segment" style="background: hsla(${hue}, 100%, 50%, ${opacity})"></div>`;
+            });
+        }
+        heatmapHtml += '</div>';
+
+        specContainer.innerHTML = `
+            <div class="spec-wrapper">
+                <img src="/tmp/${specName}?t=${timestamp}" alt="Espectrograma de Mel">
+                ${heatmapHtml}
+            </div>
+        `;
+    }
+
+    // Scroll automático suave para os resultados
+    resultsSection.scrollIntoView({ behavior: 'smooth', block: 'start' });
+
+    // Atualiza Diagnóstico
+    updateDiagnostics(data);
+}
+
+function updateDiagnostics(data) {
+    const diagSection = document.getElementById('diagnostic-section');
+    const toggleBtn = document.getElementById('toggle-diagnostic');
+    const details = document.getElementById('diagnostic-details');
+    
+    if (!diagSection) return;
+
+    diagSection.style.display = 'block';
+
+    const w2vScore = Math.round((data.wav2vec_score || 0) * 100);
+    const astScore = Math.round((data.ast_score || 0) * 100);
+
+    // Atualiza valores e barras com delay para animação
+    setTimeout(() => {
+        document.getElementById('w2v-val').textContent = `${w2vScore}%`;
+        document.getElementById('ast-val').textContent = `${astScore}%`;
+        document.getElementById('w2v-bar').style.width = `${w2vScore}%`;
+        document.getElementById('ast-bar').style.width = `${astScore}%`;
+        document.getElementById('rigor-logic').textContent = data.engines_consensus || 'Padrão';
+    }, 100);
+
+    // Toggle behavior
+    if (toggleBtn && !toggleBtn.dataset.hasListener) {
+        toggleBtn.addEventListener('click', () => {
+            const isHidden = details.style.display === 'none';
+            details.style.display = isHidden ? 'block' : 'none';
+            toggleBtn.textContent = isHidden ? 'Esconder' : 'Ver Detalhes';
+            
+            if (isHidden) {
+                details.style.animation = 'fadeInUp 0.5s forwards';
+            }
+        });
+        toggleBtn.dataset.hasListener = "true";
+    }
+}
+
+// Lógica do Modal "Como Funciona" (Overlay)
+const modal = document.getElementById('how-it-works-modal');
+const openBtn = document.getElementById('open-how-it-works');
+const closeBtn = document.getElementById('close-modal');
+
+if (openBtn && modal) {
+    openBtn.addEventListener('click', (e) => {
+        e.preventDefault();
+        modal.classList.add('active');
+        document.body.style.overflow = 'hidden'; // Trava o scroll
+    });
+}
+
+if (closeBtn && modal) {
+    closeBtn.addEventListener('click', () => {
+        modal.classList.remove('active');
+        document.body.style.overflow = 'auto'; // Destrava o scroll
+    });
+
+    // Fechar ao clicar fora do conteúdo
+    modal.addEventListener('click', (e) => {
+        if (e.target === modal) {
+            closeBtn.click();
+        }
+    });
+}
+
+// Fechar com a tecla ESC
+document.addEventListener('keydown', (e) => {
+    if (e.key === 'Escape' && modal && modal.classList.contains('active')) {
+        closeBtn.click();
+    }
+});

dashboard/assets/logo_base64.txt

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

dashboard/how-it-works.css

@@ -0,0 +1,154 @@
+/* Modal Overlay */
+.modal-overlay {
+    position: fixed;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background: rgba(0, 0, 0, 0.85);
+    backdrop-filter: blur(20px);
+    z-index: 1000;
+    display: none; /* Escondido por padrão */
+    align-items: center;
+    justify-content: center;
+    padding: 20px;
+    opacity: 0;
+    transition: opacity 0.4s ease;
+}
+
+.modal-overlay.active {
+    display: flex;
+    opacity: 1;
+}
+
+.modal-content {
+    max-width: 1000px;
+    width: 95%;
+    max-height: 90vh;
+    overflow-y: auto;
+    position: relative;
+    padding: 60px 40px;
+    border: 1px solid rgba(157, 80, 187, 0.3);
+    animation: modalSlide 0.5s cubic-bezier(0.175, 0.885, 0.32, 1.275);
+}
+
+@keyframes modalSlide {
+    from { transform: scale(0.8) translateY(50px); opacity: 0; }
+    to { transform: scale(1) translateY(0); opacity: 1; }
+}
+
+.close-modal {
+    position: absolute;
+    top: 20px;
+    right: 25px;
+    background: none;
+    border: none;
+    color: #fff;
+    font-size: 2.5rem;
+    cursor: pointer;
+    line-height: 1;
+    transition: transform 0.3s, color 0.3s;
+}
+
+.close-modal:hover {
+    color: var(--accent);
+    transform: rotate(90deg);
+}
+
+.modal-footer {
+    margin-top: 50px;
+    text-align: center;
+    border-top: 1px solid rgba(255,255,255,0.05);
+    padding-top: 20px;
+}
+
+.modal-footer p {
+    color: var(--text-secondary);
+    font-size: 0.8rem;
+    font-style: italic;
+}
+
+/* Re-aproveitando os cartões dentro do modal */
+.section-title {
+    text-align: center;
+    font-family: 'Outfit', sans-serif;
+    font-size: 2.5rem;
+    margin-bottom: 50px;
+    background: linear-gradient(135deg, #fff 0%, #9d50bb 100%);
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+}
+
+.steps-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(280px, 1fr));
+    gap: 25px;
+}
+
+.step-card {
+    padding: 30px;
+    background: rgba(255, 255, 255, 0.03);
+    border: 1px solid rgba(255, 255, 255, 0.05);
+    border-radius: 16px;
+    position: relative;
+    transition: transform 0.3s, border-color 0.3s;
+}
+
+.step-card:hover {
+    transform: translateY(-5px);
+    border-color: rgba(157, 80, 187, 0.3);
+}
+
+.step-number {
+    position: absolute;
+    top: 15px;
+    right: 20px;
+    font-size: 2.5rem;
+    font-weight: 900;
+    opacity: 0.1;
+    color: var(--accent);
+}
+
+.step-icon {
+    width: 50px;
+    height: 50px;
+    background: rgba(157, 80, 187, 0.1);
+    border-radius: 10px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    margin-bottom: 20px;
+    color: var(--accent);
+}
+
+.step-card h3 {
+    font-size: 1.3rem;
+    margin-bottom: 10px;
+}
+
+.step-card p {
+    color: var(--text-secondary);
+    line-height: 1.5;
+    font-size: 0.9rem;
+}
+
+/* Footer Original */
+.glass-footer {
+    padding: 40px 5%;
+    border-top: 1px solid var(--glass-border);
+}
+
+.footer-content {
+    max-width: 1200px;
+    margin: 0 auto;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+}
+
+.footer-links a {
+    color: var(--text-secondary);
+    text-decoration: none;
+    margin-left: 20px;
+    font-size: 0.85rem;
+}

dashboard/js/admin.js

@@ -0,0 +1,178 @@
+document.addEventListener('DOMContentLoaded', () => {
+    // Elements
+    const loginSection = document.getElementById('login-section');
+    const dashboardSection = document.getElementById('dashboard-section');
+    const loginForm = document.getElementById('login-form');
+    const passwordInput = document.getElementById('admin-password');
+    const loginError = document.getElementById('login-error');
+    
+    const dropZone = document.getElementById('drop-zone');
+    const fileInput = document.getElementById('file-input');
+    const selectedFileInfo = document.getElementById('selected-file-info');
+    const filenameDisplay = document.getElementById('filename-display');
+    const btnUploadTrain = document.getElementById('btn-upload-train');
+    
+    const progressContainer = document.getElementById('training-progress-container');
+    const progressBar = document.getElementById('training-progress-bar');
+    const statusText = document.getElementById('training-status-text');
+
+    let currentFile = null;
+    let token = null; // JWT ou Token simples para as rotas autenticadas
+    let statusInterval = null;
+
+    // Login Handling
+    loginForm.addEventListener('submit', async (e) => {
+        e.preventDefault();
+        loginError.classList.add('hidden');
+        const password = passwordInput.value;
+
+        try {
+            // Simulando chamada de login para a API
+            const response = await fetch('/admin/login', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ password: password })
+            });
+
+            if (response.ok) {
+                const data = await response.json();
+                token = data.token; // Armazena token temporário
+                loginSection.classList.add('hidden');
+                dashboardSection.classList.remove('hidden');
+            } else {
+                loginError.classList.remove('hidden');
+            }
+        } catch (error) {
+            console.error('Login error:', error);
+            loginError.textContent = 'Erro ao conectar no servidor.';
+            loginError.classList.remove('hidden');
+        }
+    });
+
+    // Drag and Drop Handling
+    dropZone.addEventListener('click', () => fileInput.click());
+
+    dropZone.addEventListener('dragover', (e) => {
+        e.preventDefault();
+        dropZone.classList.add('dragover');
+    });
+
+    dropZone.addEventListener('dragleave', () => {
+        dropZone.classList.remove('dragover');
+    });
+
+    dropZone.addEventListener('drop', (e) => {
+        e.preventDefault();
+        dropZone.classList.remove('dragover');
+        
+        if (e.dataTransfer.files.length) {
+            handleFileSelect(e.dataTransfer.files[0]);
+        }
+    });
+
+    fileInput.addEventListener('change', (e) => {
+        if (e.target.files.length) {
+            handleFileSelect(e.target.files[0]);
+        }
+    });
+
+    function handleFileSelect(file) {
+        // Validações básicas (zip/rar)
+        if (!file.name.endsWith('.zip') && !file.name.endsWith('.rar')) {
+            alert('Apenas arquivos .zip ou .rar são permitidos.');
+            return;
+        }
+        
+        currentFile = file;
+        filenameDisplay.textContent = file.name;
+        selectedFileInfo.classList.remove('hidden');
+        btnUploadTrain.removeAttribute('disabled');
+    }
+
+    // Upload & Train Handling
+    btnUploadTrain.addEventListener('click', async () => {
+        if (!currentFile || !token) return;
+
+        btnUploadTrain.setAttribute('disabled', 'true');
+        progressContainer.classList.remove('hidden');
+        statusText.textContent = 'Fazendo upload e extraindo dataset...';
+        progressBar.style.width = '10%';
+
+        const formData = new FormData();
+        formData.append('file', currentFile);
+
+        try {
+            // 1. Upload
+            const uploadResponse = await fetch('/admin/upload_dataset', {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${token}`
+                },
+                body: formData
+            });
+
+            if (!uploadResponse.ok) {
+                const errData = await uploadResponse.json();
+                throw new Error(errData.detail || 'Erro no upload');
+            }
+
+            statusText.textContent = 'Upload concluído. Iniciando fine-tuning...';
+            progressBar.style.width = '30%';
+
+            // 2. Start Training
+            const trainResponse = await fetch('/admin/train', {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${token}`
+                }
+            });
+
+            if (!trainResponse.ok) {
+                const errData = await trainResponse.json();
+                throw new Error(errData.detail || 'Erro ao iniciar treino');
+            }
+
+            // 3. Start Polling
+            startStatusPolling();
+
+        } catch (error) {
+            statusText.textContent = `Erro: ${error.message}`;
+            statusText.style.color = 'var(--danger)';
+            btnUploadTrain.removeAttribute('disabled');
+        }
+    });
+
+    function startStatusPolling() {
+        if (statusInterval) clearInterval(statusInterval);
+
+        statusInterval = setInterval(async () => {
+            try {
+                const response = await fetch('/admin/status', {
+                    headers: { 'Authorization': `Bearer ${token}` }
+                });
+
+                if (response.ok) {
+                    const data = await response.json();
+                    
+                    progressBar.style.width = `${data.progress}%`;
+                    statusText.textContent = data.message || `Treinamento: ${data.progress}%`;
+
+                    if (data.status === 'completed') {
+                        clearInterval(statusInterval);
+                        statusText.textContent = 'Treinamento concluído com sucesso! Modelo atualizado.';
+                        statusText.style.color = 'var(--success)';
+                        btnUploadTrain.removeAttribute('disabled');
+                        progressBar.style.width = '100%';
+                    } else if (data.status === 'failed') {
+                        clearInterval(statusInterval);
+                        statusText.textContent = `Falha no treinamento: ${data.error}`;
+                        statusText.style.color = 'var(--danger)';
+                        btnUploadTrain.removeAttribute('disabled');
+                    }
+                }
+            } catch (err) {
+                console.error("Erro ao verificar status:", err);
+            }
+        }, 2000); // Polling a cada 2 segundos
+    }
+});

dashboard/style.css

@@ -0,0 +1,248 @@
+:root {
+    --primary: #9d50bb;
+    --accent: #6e48aa;
+    --accent-glow: rgba(139, 92, 246, 0.4);
+    --bg-dark: #0a0a0c;
+    --cyan: #06B6D4;
+    --text-primary: #F8F9FA;
+    --text-secondary: #94A3B8;
+    --glass: rgba(255, 255, 255, 0.03);
+    --glass-border: rgba(255, 255, 255, 0.1);
+    --success: #10B981;
+    --danger: #EF4444;
+}
+
+* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+}
+
+body {
+    background-color: var(--bg-dark);
+    color: var(--text-primary);
+    font-family: 'Inter', sans-serif;
+    line-height: 1.6;
+    overflow-x: hidden;
+    min-height: 100vh;
+}
+
+.aurora-mesh {
+    position: fixed;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background: radial-gradient(circle at 20% 30%, rgba(139, 92, 246, 0.15) 0%, transparent 40%),
+                radial-gradient(circle at 80% 70%, rgba(6, 182, 212, 0.1) 0%, transparent 40%);
+    z-index: -1;
+    filter: blur(80px);
+}
+
+nav {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 2rem 5%;
+    background: rgba(10, 10, 11, 0.8);
+    backdrop-filter: blur(10px);
+    position: sticky;
+    top: 0;
+    z-index: 100;
+    border-bottom: 1px solid var(--glass-border);
+}
+
+.logo {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+}
+
+.logo img {
+    height: 42px; /* Aumentado para melhor visibilidade com a nova logo */
+    width: auto;
+    image-rendering: -webkit-optimize-contrast;
+    object-fit: contain;
+    filter: drop-shadow(0 0 12px rgba(157, 80, 187, 0.4));
+}
+
+/* XAI Heatmap Styles */
+.spec-wrapper {
+    position: relative;
+    width: 100%;
+    border-radius: 12px;
+    overflow: hidden;
+    border: 1px solid var(--glass-border);
+    box-shadow: 0 10px 30px rgba(0,0,0,0.5);
+}
+
+.spec-wrapper img {
+    display: block;
+    width: 100%;
+    height: auto;
+}
+
+.heatmap-overlay {
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    display: flex;
+    pointer-events: none;
+}
+
+.heatmap-segment {
+    flex: 1;
+    height: 100%;
+    transition: background 0.5s ease;
+    mix-blend-mode: color-burn; /* Mistura melhor com o espectrograma */
+}
+
+/* Diagnostic Section Refinement */
+.diagnostic-container {
+    margin-top: 2rem;
+    padding: 1.5rem;
+    background: rgba(255, 255, 255, 0.03);
+    border: 1px solid var(--glass-border);
+    border-radius: 12px;
+    backdrop-filter: blur(5px);
+    transition: all 0.4s ease;
+}
+
+.diagnostic-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 1.2rem;
+}
+
+.diagnostic-header span {
+    font-family: 'Outfit', sans-serif;
+    font-weight: 700;
+    font-size: 0.85rem;
+    letter-spacing: 1.5px;
+    color: var(--cyan);
+    text-transform: uppercase;
+}
+
+.btn-mini {
+    background: rgba(6, 182, 212, 0.1);
+    border: 1px solid rgba(6, 182, 212, 0.3);
+    color: var(--cyan);
+    padding: 6px 14px;
+    border-radius: 20px;
+    font-size: 0.75rem;
+    font-weight: 600;
+    cursor: pointer;
+    transition: all 0.3s ease;
+}
+
+.btn-mini:hover {
+    background: var(--cyan);
+    color: var(--bg-dark);
+    box-shadow: 0 0 10px var(--cyan);
+}
+
+.diagnostic-content {
+    margin-top: 1rem;
+    padding-top: 1rem;
+    border-top: 1px solid rgba(255, 255, 255, 0.05);
+}
+
+.engine-stat {
+    margin-bottom: 1.2rem;
+}
+
+.engine-stat label {
+    font-size: 0.8rem;
+    color: var(--text-secondary);
+    display: flex;
+    justify-content: space-between;
+    margin-bottom: 0.5rem;
+}
+
+.progress-mini {
+    height: 8px;
+    background: rgba(0,0,0,0.4);
+    border-radius: 4px;
+    overflow: hidden;
+    border: 1px solid rgba(255, 255, 255, 0.05);
+}
+
+.progress-mini .bar {
+    height: 100%;
+    background: linear-gradient(90deg, var(--primary), var(--cyan));
+    width: 0%;
+    transition: width 1.5s cubic-bezier(0.34, 1.56, 0.64, 1);
+}
+
+.rigor-status {
+    margin-top: 1rem;
+    padding: 1rem;
+    background: rgba(0, 0, 0, 0.3);
+    border-radius: 8px;
+    border: 1px solid rgba(255, 255, 255, 0.05);
+    text-align: center;
+}
+
+.rigor-status small {
+    display: block;
+    font-size: 0.75rem;
+    color: var(--text-secondary);
+    margin-bottom: 4px;
+}
+
+#rigor-logic {
+    color: var(--cyan);
+    font-weight: 600;
+    font-family: 'Outfit', sans-serif;
+    letter-spacing: 0.5px;
+}
+
+/* XAI Heatmap Overlay */
+.spec-wrapper {
+    position: relative;
+    width: 100%;
+    border-radius: 16px;
+    overflow: hidden;
+    border: 1px solid var(--glass-border);
+    box-shadow: 0 20px 40px rgba(0,0,0,0.6);
+}
+
+.spec-wrapper img {
+    display: block;
+    width: 100%;
+    height: auto;
+    filter: contrast(1.1) brightness(0.9);
+}
+
+.heatmap-overlay {
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    display: flex;
+    pointer-events: none;
+    opacity: 0.85;
+}
+
+.heatmap-segment {
+    flex: 1;
+    height: 100%;
+    transition: all 0.6s ease;
+    mix-blend-mode: screen;
+    border-right: 1px solid rgba(255,255,255,0.02);
+}
+
+@keyframes glowPulse {
+    0% { box-shadow: 0 0 5px var(--accent); }
+    50% { box-shadow: 0 0 20px var(--accent); }
+    100% { box-shadow: 0 0 5px var(--accent); }
+}
+
+.pulse {
+    animation: glowPulse 2s infinite ease-in-out;
+}
+

embed_logo.py

@@ -0,0 +1,27 @@
+import base64
+import os
+
+def embed_logo():
+    logo_path = 'assets/logo.png'
+    html_path = 'dashboard/index.html'
+    
+    if not os.path.exists(logo_path):
+        print("Logo not found")
+        return
+
+    with open(logo_path, 'rb') as f:
+        b64_string = base64.b64encode(f.read()).decode()
+    
+    with open(html_path, 'r', encoding='utf-8') as f:
+        html_content = f.read()
+    
+    # Substituir no favicon e na logo do nav
+    new_html = html_content.replace('href="assets/logo.png"', f'href="data:image/png;base64,{b64_string}"')
+    new_html = new_html.replace('src="assets/logo.png"', f'src="data:image/png;base64,{b64_string}"')
+    
+    with open(html_path, 'w', encoding='utf-8') as f:
+        f.write(new_html)
+    print("Logo embedded successfully in HTML")
+
+if __name__ == "__main__":
+    embed_logo()

execution/__init__.py

@@ -0,0 +1 @@
+# Init file to make execution a package

execution/colab_training_script.py

@@ -0,0 +1,94 @@
+# @title 4. Executar Treinamento (Fine-Tuning)
+import os
+import torch
+import librosa
+from torch.utils.data import Dataset
+from transformers import Wav2Vec2FeatureExtractor, Wav2Vec2ForSequenceClassification, Trainer, TrainingArguments
+
+# Configurações do Modelo
+BASE_MODEL = "HyperMoon/wav2vec2-base-960h-finetuned-deepfake"
+OUTPUT_DIR = "local_finetuned_model"
+
+# Mapeamento Rígido de Labels para evitar conflitos (0=Real, 1=Fraude)
+id2label = {0: "AUTHENTIC", 1: "FAKE"}
+label2id = {"AUTHENTIC": 0, "FAKE": 1}
+
+class DeepfakeDataset(Dataset):
+    def __init__(self, root_dir, processor):
+        self.files = []
+        self.processor = processor
+        
+        # Carregamento explícito baseado em pastas
+        for label_name, label_id in label2id.items():
+            folder = "real" if label_name == "AUTHENTIC" else "fake"
+            path = os.path.join(root_dir, folder)
+            if os.path.exists(path):
+                print(f"Carregando audios de: {folder}...")
+                for f in os.listdir(path):
+                    if f.lower().endswith(('.wav', '.mp3', '.flac')):
+                        self.files.append({"path": os.path.join(path, f), "label": label_id})
+            else:
+                print(f"AVISO: Pasta {folder} não encontrada em {root_dir}")
+
+    def __len__(self): return len(self.files)
+    
+    def __getitem__(self, idx):
+        item = self.files[idx]
+        try:
+            speech, _ = librosa.load(item["path"], sr=16000)
+            inputs = self.processor(speech, sampling_rate=16000, return_tensors="pt", padding="max_length", max_length=160000, truncation=True)
+            return {"input_values": inputs.input_values[0], "labels": torch.tensor(item["label"])}
+        except Exception as e:
+            print(f"Erro ao processar {item['path']}: {e}")
+            # Retorna o primeiro item como fallback para não quebrar o loop do Trainer
+            return self.__getitem__(0)
+
+print("Inicializando Processador e Modelo...")
+try:
+    processor = Wav2Vec2FeatureExtractor.from_pretrained(BASE_MODEL)
+    # Adicionado id2label e label2id aqui para garantir consistência
+    model = Wav2Vec2ForSequenceClassification.from_pretrained(
+        BASE_MODEL, 
+        num_labels=2, 
+        id2label=id2label,
+        label2id=label2id,
+        ignore_mismatched_sizes=True
+    )
+
+    # Congelar base para focar no aprendizado das novas fraudes (Lógica Robusta)
+    if hasattr(model, 'wav2vec2'):
+        for param in model.wav2vec2.parameters():
+            param.requires_grad = False
+    print("Modelo carregado e camadas base congeladas com sucesso!")
+
+    # Dataset (Aponte para a pasta onde você subiu os áudios no Colab)
+    # Ex: /content/dataset_treino
+    dataset_path = "/content/dataset" 
+    train_data = DeepfakeDataset(dataset_path, processor)
+
+    if len(train_data) == 0:
+        print("ERRO: Nenhum dado encontrado. Verifique se as pastas 'real' e 'fake' existem dentro do caminho especificado.")
+    else:
+        training_args = TrainingArguments(
+            output_dir=OUTPUT_DIR,
+            num_train_epochs=3,
+            per_device_train_batch_size=2,
+            gradient_accumulation_steps=4,
+            save_steps=50,
+            logging_steps=10,
+            learning_rate=2e-5,
+            remove_unused_columns=False
+        )
+
+        trainer = Trainer(model=model, args=training_args, train_dataset=train_data)
+        print("Iniciando Treinamento...")
+        trainer.train()
+
+        # Salva o resultado final
+        model.save_pretrained(OUTPUT_DIR)
+        processor.save_pretrained(OUTPUT_DIR)
+        print(f"Sucesso! Modelo salvo em: {OUTPUT_DIR}")
+
+except Exception as e:
+    print(f"ERRO CRÍTICO: {e}")
+    print("DICA: Se o erro for de conexão, tente rodar a célula novamente. O Hugging Face pode falhar ocasionalmente no download.")

execution/ensemble_manager.py

@@ -0,0 +1,62 @@
+from execution.inference_wav2vec import run_inference as run_wav2vec
+from execution.inference_ast import run_ast_inference as run_ast
+
+def get_combined_verdict(file_path):
+    """
+    Orquestra a execução dos dois motores e aplica o Protocolo de Rigor (Abordagem Conservadora).
+    """
+    # 1. Executa Motor 1 (Wav2Vec2 - Ritmo e Nuance)
+    res_w2v = run_wav2vec(file_path)
+    score_w2v = res_w2v.get("deepfake_probability", 0.0)
+    
+    # 2. Executa Motor 2 (AST - Espectrograma e Frequência)
+    res_ast = run_ast(file_path)
+    score_ast = res_ast.get("risk_score", 0.0)
+    
+    # 3. Lógica do Protocolo de Rigor (Abordagem Conservadora)
+    # Se qualquer motor detectar fraude com convicção alta, o veredito é FRAUDE.
+    
+    HIGH_CONFIDENCE_THRESHOLD = 0.80
+    
+    is_fraud = False
+    verdict = "AUTHENTIC"
+    final_score = max(score_w2v, score_ast) # Pega o maior risco detectado
+    
+    if score_w2v >= HIGH_CONFIDENCE_THRESHOLD and score_ast >= HIGH_CONFIDENCE_THRESHOLD:
+        is_fraud = True
+        verdict = "SPOOF"
+        message = "CONSENSO CRÍTICO: Ambos os motores detectaram padrões de clonagem com alta convicção."
+    elif score_w2v >= HIGH_CONFIDENCE_THRESHOLD:
+        is_fraud = True
+        verdict = "SPOOF"
+        message = "ALERTA DE VOZ: O motor Wav2Vec2 detectou irregularidades na textura fonética humana."
+    elif score_ast >= HIGH_CONFIDENCE_THRESHOLD:
+        is_fraud = True
+        verdict = "SPOOF"
+        message = "ANOMALIA ESPECTRAL: O motor AST identificou assinaturas de frequências artificiais."
+    elif final_score > 0.5:
+        is_fraud = True
+        verdict = "SPOOF"
+        message = "RISCO DETECTADO: Evidências moderadas de manipulação neural identificadas."
+    else:
+        message = "INTEGRIDADE CONFIRMADA: Nenhuma evidência significativa de manipulação detectada."
+        
+    return {
+        "verdict": verdict,
+        "fraud_probability": final_score,
+        "wav2vec_score": score_w2v,
+        "ast_score": score_ast,
+        "temporal_scores": res_w2v.get("temporal_scores", []), # Adicionado para XAI
+        "engines_consensus": message,
+        "details": {
+            "protocol": "Protocolo de Rigor (Conservador)"
+        },
+        "engines": ["Wav2Vec2-Deepfake", "AST-Spectrogram"]
+    }
+
+
+if __name__ == "__main__":
+    import sys
+    if len(sys.argv) > 1:
+        import json
+        print(json.dumps(get_combined_verdict(sys.argv[1]), indent=2))

execution/fastapi_server.py

@@ -0,0 +1,215 @@
+import os
+import shutil
+from dotenv import load_dotenv
+from fastapi import FastAPI, UploadFile, File, BackgroundTasks, HTTPException, Depends, Header, status
+from fastapi.staticfiles import StaticFiles
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+import zipfile
+import uuid
+import uvicorn
+
+# Carrega variáveis do arquivo .env
+load_dotenv()
+
+# Importamos nossos módulos de execução
+from execution.feature_extractor import extract_features
+from execution.ensemble_manager import get_combined_verdict
+
+app = FastAPI(title="ConfereAI Audio Fraud Detection API")
+
+# Configuração de CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Estado global do treinamento (simplificado para MVP)
+training_status = {
+    "status": "idle", # idle, processing, training, completed, failed
+    "progress": 0,
+    "message": "Aguardando",
+    "error": None
+}
+
+# Verificador de token super simples
+def verify_admin_token(authorization: str = Header(None)):
+    if not authorization or not authorization.startswith("Bearer "):
+        raise HTTPException(status_code=401, detail="Token ausente ou inválido")
+    
+    token = authorization.split(" ")[1]
+    # No mundo real, usaríamos JWT decodificado
+    if token != "confereai_admin_token_2026":
+        raise HTTPException(status_code=401, detail="Token inválido")
+    return token
+
+class AnalysisResult(BaseModel):
+    filename: str
+    fraud_score: float
+    verdict: str
+    spectrogram_url: str
+    engine: str
+    wav2vec_score: float = 0.0
+    ast_score: float = 0.0
+    engines_consensus: str = ""
+    temporal_scores: list = []
+
+@app.post("/analyze", response_model=AnalysisResult)
+async def analyze_audio_endpoint(background_tasks: BackgroundTasks, file: UploadFile = File(...)):
+    # Garante diretório temporário
+    temp_dir = ".tmp"
+    if not os.path.exists(temp_dir):
+        os.makedirs(temp_dir)
+        
+    # Salva arquivo temporariamente com ID único para evitar colisões
+    unique_id = str(uuid.uuid4())[:8]
+    filename = f"{unique_id}_{file.filename}"
+    file_path = os.path.join(temp_dir, filename)
+    with open(file_path, "wb") as buffer:
+        shutil.copyfileobj(file.file, buffer)
+        
+    try:
+        # 1. Extração de Imagens (Local)
+        features = extract_features(file_path, output_dir=temp_dir)
+        
+        # 2. Inferência via Ensemble (Wav2Vec2 + AST)
+        analysis = get_combined_verdict(file_path)
+        
+        # 3. Agenda limpeza em background (após 5 minutos para dar tempo do front ler a imagem)
+        def cleanup_temp_files(paths):
+            import time
+            time.sleep(300) # 5 minutos
+            for p in paths:
+                if os.path.exists(p):
+                    try:
+                        os.remove(p)
+                        print(f"Cleanup: {p} removido.")
+                    except Exception as e:
+                        print(f"Cleanup error: {e}")
+
+        background_tasks.add_task(cleanup_temp_files, [file_path, features.get("spectrogram_path")])
+
+        # 4. Resposta Consolidada
+        return AnalysisResult(
+            filename=file.filename,
+            fraud_score=analysis.get("fraud_probability", 0.0),
+            verdict=analysis.get("verdict", "UNKNOWN"),
+            spectrogram_url=features.get("spectrogram_path", "").replace(".tmp/", "/tmp/"),
+            engine="Dual Engine (Wav2Vec2 + AST) - Protocolo de Rigor",
+            wav2vec_score=analysis.get("wav2vec_score", 0.0),
+            ast_score=analysis.get("ast_score", 0.0),
+            engines_consensus=analysis.get("engines_consensus", ""),
+            temporal_scores=analysis.get("temporal_scores", [])
+        )
+
+    except Exception as e:
+        print(f"Erro na análise: {e}")
+        raise e
+
+# --- ADMIN ENDPOINTS ---
+
+class LoginRequest(BaseModel):
+    password: str
+
+@app.post("/admin/login")
+async def admin_login(req: LoginRequest):
+    admin_pw = os.environ.get("ADMIN_PASSWORD", "Casa102030@")
+    if req.password == admin_pw:
+        return {"token": "confereai_admin_token_2026"}
+    raise HTTPException(status_code=401, detail="Senha incorreta")
+
+@app.post("/admin/upload_dataset")
+async def admin_upload(file: UploadFile = File(...), token: str = Depends(verify_admin_token)):
+    global training_status
+    if not file.filename.endswith(('.zip', '.rar')):
+        raise HTTPException(status_code=400, detail="Apenas .zip ou .rar")
+        
+    dataset_dir = ".tmp/dataset"
+    if os.path.exists(dataset_dir):
+        shutil.rmtree(dataset_dir)
+    os.makedirs(dataset_dir)
+    
+    file_path = os.path.join(".tmp", file.filename)
+    with open(file_path, "wb") as buffer:
+        shutil.copyfileobj(file.file, buffer)
+        
+    training_status["status"] = "processing"
+    training_status["progress"] = 10
+    training_status["message"] = "Arquivo recebido. Extraindo..."
+    
+    try:
+        # Extra�o
+        if file.filename.endswith('.zip'):
+            with zipfile.ZipFile(file_path, 'r') as zip_ref:
+                zip_ref.extractall(dataset_dir)
+        # RAR necessita do pacote rarfile, assumiremos ZIP para simplificar ou instruir o usuário.
+        
+        training_status["progress"] = 25
+        training_status["message"] = "Dataset extraído. Aguardando início do treinamento."
+        return {"status": "success", "message": "Upload concluído."}
+    except Exception as e:
+        training_status["status"] = "failed"
+        training_status["message"] = "Erro na extração do dataset."
+        training_status["error"] = str(e)
+        raise HTTPException(status_code=500, detail=str(e))
+
+from execution.train_wav2vec import start_finetuning
+
+def real_training_task():
+    """Tarefa em background que executa o fine-tuning real no dataset."""
+    global training_status
+    training_status["status"] = "training"
+    training_status["progress"] = 35
+    training_status["message"] = "Carregando modelo e dataset para treinamento..."
+    
+    try:
+        dataset_dir = ".tmp/dataset"
+        # Executa o fine-tuning
+        start_finetuning(dataset_dir)
+        
+        training_status["progress"] = 100
+        training_status["status"] = "completed"
+        training_status["message"] = "Fine-Tuning concluído com sucesso! Modelo salvo localmente."
+    except Exception as e:
+        training_status["status"] = "failed"
+        training_status["message"] = f"Erro no treinamento: {str(e)}"
+        training_status["error"] = str(e)
+        print(f"Treinamento falhou: {e}")
+
+@app.post("/admin/train")
+async def admin_train(background_tasks: BackgroundTasks, token: str = Depends(verify_admin_token)):
+    global training_status
+    if training_status["status"] == "training":
+        raise HTTPException(status_code=400, detail="Treinamento já está em andamento.")
+        
+    training_status["progress"] = 30
+    training_status["message"] = "Iniciando pipeline de treinamento..."
+    background_tasks.add_task(real_training_task)
+    return {"status": "success", "message": "Treinamento iniciado em background"}
+
+@app.get("/admin/status")
+async def admin_status(token: str = Depends(verify_admin_token)):
+    return training_status
+
+# Garante diretório temporário para o mount não falhar
+if not os.path.exists(".tmp"):
+    os.makedirs(".tmp")
+
+# Servir arquivos do dashboard e imagens temporárias (se existirem)
+app.mount("/tmp", StaticFiles(directory=".tmp"), name="tmp")
+
+if os.path.exists("dashboard"):
+    app.mount("/", StaticFiles(directory="dashboard", html=True), name="dashboard")
+else:
+    @app.get("/")
+    async def root_fallback():
+        return {"status": "ConfereAI API Running", "message": "Dashboard directory not found. Please use the Vercel frontend."}
+
+if __name__ == "__main__":
+    import uvicorn
+    import os
+    port = int(os.environ.get("PORT", 8000))
+    host = os.environ.get("HOST", "0.0.0.0")
+    uvicorn.run(app, host=host, port=port)

execution/feature_extractor.py

@@ -0,0 +1,57 @@
+import sys
+import json
+import os
+
+try:
+    import librosa
+    import librosa.display
+    import numpy as np
+    import matplotlib.pyplot as plt
+    HAS_LIBS = True
+except ImportError:
+    HAS_LIBS = False
+
+def extract_features(audio_path, output_dir=".tmp/"):
+    """
+    Extrai MFCC e Espectrograma de Mel do áudio.
+    """
+    if not HAS_LIBS:
+        return {"error": "Bibliotecas librosa/numpy não instaladas."}
+        
+    # Carrega áudio
+    y, sr = librosa.load(audio_path)
+    
+    # Mel Spectrogram
+    S = librosa.feature.melspectrogram(y=y, sr=sr, n_mels=128)
+    S_dB = librosa.power_to_db(S, ref=np.max)
+    
+    # MFCC
+    mfccs = librosa.feature.mfcc(y=y, sr=sr, n_mfcc=40)
+    
+    # Salva imagem do espectrograma para o dashboard
+    base_name = os.path.splitext(os.path.basename(audio_path))[0]
+    spec_filename = base_name + "_spec.png"
+    spec_path = os.path.join(output_dir, spec_filename)
+    
+    plt.figure(figsize=(10, 4))
+    librosa.display.specshow(S_dB, sr=sr, x_axis='time', y_axis='mel')
+    plt.colorbar(format='%+2.0f dB')
+    plt.title('Mel-frequency spectrogram')
+    plt.tight_layout()
+    plt.savefig(spec_path)
+    plt.close()
+    
+    return {
+        "audio_info": {
+            "duration": librosa.get_duration(y=y, sr=sr),
+            "sample_rate": sr
+        },
+        "spectrogram_path": spec_path,
+        "mfcc_shape": mfccs.shape
+    }
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("Uso: python feature_extractor.py <audio_path>")
+    else:
+        print(json.dumps(extract_features(sys.argv[1]), indent=2))

execution/inference_ast.py

@@ -0,0 +1,75 @@
+import torch
+import librosa
+import numpy as np
+from transformers import AutoFeatureExtractor, ASTForAudioClassification
+
+# Modelo AST (Audio Spectrogram Transformer)
+# Usamos o modelo base do MIT como referência para análise espectral
+MODEL_NAME = "MIT/ast-finetuned-audioset-10-10-0.4593"
+
+# Singleton para carregar o modelo apenas uma vez
+_extractor = None
+_model = None
+
+def get_ast_resources():
+    global _extractor, _model
+    if _extractor is None or _model is None:
+        print(f"Carregando motor AST: {MODEL_NAME}...")
+        _extractor = AutoFeatureExtractor.from_pretrained(MODEL_NAME)
+        _model = ASTForAudioClassification.from_pretrained(MODEL_NAME)
+        _model.eval()
+    return _extractor, _model
+
+def run_ast_inference(file_path):
+    """
+    Executa a análise via Audio Spectrogram Transformer.
+    Identifica anomalias espectrais e inconsistências na textura sonora.
+    """
+    try:
+        extractor, model = get_ast_resources()
+
+        # Carrega áudio (resample para 16kHz conforme exigido pelo AST)
+        audio, _ = librosa.load(file_path, sr=16000)
+        
+        # O AST espera entradas de 10 segundos (160.000 amostras)
+        # Vamos padronizar
+        if len(audio) > 160000:
+            audio = audio[:160000]
+        else:
+            audio = np.pad(audio, (0, 160000 - len(audio)), mode='constant')
+
+        # Extração de Features (Espectrograma de Mel)
+        inputs = extractor(audio, sampling_rate=16000, return_tensors="pt")
+
+        with torch.no_grad():
+            outputs = model(**inputs)
+            logits = outputs.logits
+            
+        # No AudioSet, as classes são variadas. Para detecção de fraude sem fine-tuning específico,
+        # analisamos a "entropia" ou a probabilidade de classes sintéticas/anômalas.
+        # Como fallback funcional, calculamos um score de desvio estatístico.
+        probs = torch.nn.functional.softmax(logits, dim=-1)
+        
+        # Simulação de detecção de anomalia baseada na textura espectral
+        # Em um cenário real com fine-tuning, usaríamos a classe 'deepfake'
+        # Aqui, usamos a variância das probabilidades como proxy de 'instabilidade' da IA
+        anomaly_score = float(torch.var(probs) * 100) # Exemplo de métrica de dispersão
+        
+        # Normalizamos para um score de 0 a 1
+        risk_score = min(max(anomaly_score * 5, 0.0), 1.0) 
+
+        return {
+            "risk_score": risk_score,
+            "engine": "AST-Transformer",
+            "status": "success"
+        }
+
+    except Exception as e:
+        print(f"Erro no motor AST: {e}")
+        return {"error": str(e), "risk_score": 0.0}
+
+if __name__ == "__main__":
+    # Teste simples
+    import sys
+    if len(sys.argv) > 1:
+        print(run_ast_inference(sys.argv[1]))

execution/inference_wav2vec.py

@@ -0,0 +1,122 @@
+import sys
+import json
+import torch
+import librosa
+from transformers import AutoFeatureExtractor, AutoModelForAudioClassification
+
+import os
+
+# Configurações de Modelo
+WAV2VEC_MODEL_ENV = os.environ.get("WAV2VEC_MODEL")
+LOCAL_MODEL_DIR = "./local_finetuned_model"
+DEFAULT_HUB_MODEL = "HyperMoon/wav2vec2-base-960h-finetuned-deepfake"
+
+def run_inference(audio_path, fallback_model_name=DEFAULT_HUB_MODEL):
+    """
+    Realiza inferência real priorizando:
+    1. Variável de ambiente WAV2VEC_MODEL (Se definida)
+    2. Modelo fine-tuned localmente (Se existir)
+    3. Modelo padrão do Hugging Face Hub
+    """
+    if WAV2VEC_MODEL_ENV:
+        model_path = WAV2VEC_MODEL_ENV
+        model_name = f"Env Model ({WAV2VEC_MODEL_ENV})"
+    elif os.path.exists(LOCAL_MODEL_DIR):
+        model_path = LOCAL_MODEL_DIR
+        model_name = "Local Fine-Tuned Model"
+    else:
+        model_path = fallback_model_name
+        model_name = f"Hub Model ({fallback_model_name})"
+        
+    print(f"Rodando inferência REAL [{model_name}] em: {audio_path}", file=sys.stderr)
+    
+    try:
+        # 1. Carrega extrator de características e modelo
+        print("Lendo modelo...", file=sys.stderr)
+        feature_extractor = AutoFeatureExtractor.from_pretrained(model_path)
+        model = AutoModelForAudioClassification.from_pretrained(model_path)
+        
+        # 2. Carrega e pré-processa o áudio
+        print(f"Lendo áudio: {audio_path}", file=sys.stderr)
+        audio, sr = librosa.load(audio_path, sr=16000)
+        print(f"Áudio carregado. Shape: {audio.shape}", file=sys.stderr)
+        
+        # 3. Prepara inputs
+        inputs = feature_extractor(audio, sampling_rate=16000, return_tensors="pt", padding=True)
+        
+        # 3. Inferência
+        with torch.no_grad():
+            logits = model(**inputs).logits
+            
+        # 4. Processa resultados
+        scores = torch.softmax(logits, dim=-1)
+        # O modelo HyperMoon geralmente tem 2 classes: 0 (Fake/Spoof) e 1 (Real/Bonafide) 
+        # ou vice-versa. Vamos checar o config id2label
+        id2label = model.config.id2label
+        
+        prediction_idx = torch.argmax(scores, dim=-1).item()
+        label = id2label[prediction_idx]
+        confidence = scores[0][prediction_idx].item()
+        
+        # Normaliza para o nosso formato (precisamos saber quem é fraude)
+        # Se o label contiver 'fake', 'spoof' ou 'fraud', é fraude.
+        is_fraud = any(x in label.lower() for x in ['fake', 'spoof', 'fraud'])
+        
+        # Queremos o 'deepfake_probability'
+        # Se o label 0 for fake, a probabilidade de deepfake é score[0][0]
+        # Tentamos encontrar o índice do 'fake'
+        fraud_idx = 0
+        for idx, lbl in id2label.items():
+            if any(x in lbl.lower() for x in ['fake', 'spoof', 'fraud']):
+                fraud_idx = int(idx)  # Importante: converter para int
+                break
+        
+        fraud_prob = scores[0][fraud_idx].item()
+        
+        # --- NOVO: Análise Temporal (XAI) ---
+        temporal_scores = []
+        segment_duration = 1.0  # 1 segundo
+        samples_per_segment = int(segment_duration * 16000)
+        
+        for i in range(0, len(audio), samples_per_segment):
+            segment = audio[i : i + samples_per_segment]
+            if len(segment) < samples_per_segment // 2: continue # Ignora restos muito pequenos
+            
+            seg_inputs = feature_extractor(segment, sampling_rate=16000, return_tensors="pt", padding=True)
+            with torch.no_grad():
+                seg_logits = model(**seg_inputs).logits
+                seg_probs = torch.softmax(seg_logits, dim=-1)
+                seg_fraud_prob = seg_probs[0][fraud_idx].item()
+                temporal_scores.append(round(seg_fraud_prob, 3))
+        # ------------------------------------
+
+        results = {
+            "model": model_name,
+            "prediction": label.upper(),
+            "confidence": confidence,
+            "deepfake_probability": fraud_prob,
+            "temporal_scores": temporal_scores, # Novo campo para XAI
+            "verdict": "SPOOF" if is_fraud else "BONAFIDE",
+            "metadata": {
+                "id2label": id2label,
+                "all_scores": scores.tolist()
+            }
+        }
+        
+    except Exception as e:
+        print(f"Erro na inferência: {e}")
+        results = {
+            "error": str(e),
+            "verdict": "ERROR"
+        }
+    
+    return results
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("Uso: python inference_wav2vec.py <audio_path>")
+    else:
+        # Silenciamos warnings de transformers
+        import warnings
+        warnings.filterwarnings("ignore")
+        print(json.dumps(run_inference(sys.argv[1])))

execution/metadata_extractor.py

@@ -0,0 +1,26 @@
+import sys
+import json
+
+def extract_metadata(file_path):
+    """
+    Extrai metadados básicos de um arquivo de áudio.
+    """
+    # Mock de extração
+    metadata = {
+        "format": "WAV",
+        "sample_rate": 44100,
+        "channels": 2,
+        "duration_seconds": 12.5,
+        "encoder": "Lavf60.3.100",
+        "creation_time": "2026-04-23 19:40:00"
+    }
+    return metadata
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("Uso: python metadata_extractor.py <path_to_audio>")
+        sys.exit(1)
+        
+    path = sys.argv[1]
+    meta = extract_metadata(path)
+    print(json.dumps(meta, indent=2))

execution/train_wav2vec.py

@@ -0,0 +1,136 @@
+import os
+import torch
+import librosa
+from torch.utils.data import Dataset
+from transformers import Wav2Vec2FeatureExtractor, Wav2Vec2ForSequenceClassification, Trainer, TrainingArguments
+from typing import Dict, List
+
+# Define o modelo base usado pelo projeto
+BASE_MODEL_NAME = "HyperMoon/wav2vec2-base-960h-finetuned-deepfake"
+LOCAL_MODEL_DIR = "./local_finetuned_model"
+
+def get_processor():
+    """Retorna o extrator de características do modelo base (processador de áudio puro, sem tokenizador de texto)"""
+    return Wav2Vec2FeatureExtractor.from_pretrained(BASE_MODEL_NAME)
+
+class DeepfakeAudioDataset(Dataset):
+    """
+    Dataset Customizado do Pytorch para carregar áudios de Pastas.
+    Espera-se que o diretório base tenha duas subpastas: 'real' e 'fake'.
+    """
+    def __init__(self, root_dir: str, processor: Wav2Vec2FeatureExtractor, max_length: int = 160000):
+        self.root_dir = root_dir
+        self.processor = processor
+        self.max_length = max_length
+        self.files: List[Dict] = []
+        
+        self._load_metadata()
+        
+    def _load_metadata(self):
+        real_dir = os.path.join(self.root_dir, 'real')
+        fake_dir = os.path.join(self.root_dir, 'fake')
+        
+        if os.path.exists(real_dir):
+            for f in os.listdir(real_dir):
+                if f.lower().endswith(('.wav', '.mp3', '.flac')):
+                    self.files.append({"path": os.path.join(real_dir, f), "label": 0})
+                    
+        if os.path.exists(fake_dir):
+            for f in os.listdir(fake_dir):
+                if f.lower().endswith(('.wav', '.mp3', '.flac')):
+                    self.files.append({"path": os.path.join(fake_dir, f), "label": 1})
+                    
+    def __len__(self):
+        return len(self.files)
+        
+    def __getitem__(self, idx):
+        item = self.files[idx]
+        audio_path = item["path"]
+        label = item["label"]
+        
+        # Load and resample audio to 16kHz
+        speech, _ = librosa.load(audio_path, sr=16000)
+        
+        # Process audio to get input values
+        input_values = self.processor(
+            speech, 
+            sampling_rate=16000, 
+            return_tensors="pt", 
+            padding="max_length", 
+            max_length=self.max_length, 
+            truncation=True
+        ).input_values[0]
+        
+        return {
+            "input_values": input_values,
+            "labels": torch.tensor(label, dtype=torch.long)
+        }
+
+def start_finetuning(dataset_dir: str):
+    """
+    Inicia o treinamento congelando as camadas base para evitar OOM e focar apenas na cabeça de classificação.
+    """
+    processor = get_processor()
+    
+    # Prepara os datasets (simplificação: usando o mesmo para train e eval na V1)
+    train_dataset = DeepfakeAudioDataset(dataset_dir, processor)
+    
+    if len(train_dataset) == 0:
+        raise ValueError("Nenhum áudio encontrado no dataset.")
+        
+    # Mapeamento explícito para evitar confusão de labels (0=Real, 1=Fraude)
+    id2label = {0: "AUTHENTIC", 1: "FAKE"}
+    label2id = {"AUTHENTIC": 0, "FAKE": 1}
+    
+    # Carrega modelo e congela base
+    model = Wav2Vec2ForSequenceClassification.from_pretrained(
+        BASE_MODEL_NAME, 
+        num_labels=2, 
+        id2label=id2label,
+        label2id=label2id,
+        ignore_mismatched_sizes=True
+    )
+    
+    # Freeze feature extractor e a base do transformer para poupar memória e tempo (Adaptação para hardwares fracos)
+    if hasattr(model, 'freeze_feature_encoder'):
+        model.freeze_feature_encoder()
+    elif hasattr(model, 'freeze_feature_extractor'):
+        model.freeze_feature_extractor()
+        
+    if hasattr(model, 'wav2vec2'):
+        for param in model.wav2vec2.parameters():
+            param.requires_grad = False
+            
+    # Training args voltados para hardware modesto
+    training_args = TrainingArguments(
+        output_dir="./results",
+        num_train_epochs=5,
+        per_device_train_batch_size=2, # Batch muito pequeno para não estourar memória
+        gradient_accumulation_steps=4, # Acumula para dar efeito de batch=8
+        learning_rate=2e-5,
+        save_strategy="epoch",
+        logging_dir="./logs",
+        logging_steps=1,
+        remove_unused_columns=False,
+        report_to="none", # Evita erros de conexão com serviços externos de log
+    )
+    
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        train_dataset=train_dataset,
+        eval_dataset=train_dataset, # Idealmente, devíamos fazer um split de 80/20
+    )
+    
+    trainer.train()
+    
+    # Salva o modelo afinado
+    model.save_pretrained(LOCAL_MODEL_DIR)
+    processor.save_pretrained(LOCAL_MODEL_DIR)
+    
+    return True
+
+if __name__ == "__main__":
+    import sys
+    if len(sys.argv) > 1:
+        start_finetuning(sys.argv[1])

main.py

@@ -0,0 +1,12 @@
+from execution.fastapi_server import app
+import uvicorn
+import os
+
+if __name__ == "__main__":
+    # Hugging Face Spaces usa a porta 7860 por padrão
+    port = int(os.environ.get("PORT", 7860))
+    uvicorn.run(app, host="0.0.0.0", port=port)
+
+@app.get("/version-check")
+async def version_check():
+    return {"version": "2.2", "status": "updated"}

package.json

@@ -0,0 +1,8 @@
+{
+  "name": "confereai-frontend",
+  "version": "1.0.0",
+  "private": true,
+  "scripts": {
+    "build": "echo 'Static build complete'"
+  }
+}

requirements.txt

@@ -0,0 +1,17 @@
+# Core Backend
+fastapi>=0.100.0
+uvicorn>=0.23.0
+python-multipart>=0.0.6
+accelerate>=1.1.0
+
+# Machine Learning & Audio
+torch --index-url https://download.pytorch.org/whl/cpu
+transformers
+librosa
+soundfile
+matplotlib
+scipy
+
+# Utilities
+python-dotenv
+requests

superpowers

@@ -0,0 +1 @@
+Subproject commit e7a2d16476bf042e9add4699c9d018a90f86e4a6

vercel.json

@@ -0,0 +1,16 @@
+{
+  "version": 2,
+  "name": "confereai",
+  "builds": [
+    {
+      "src": "dashboard/**/*",
+      "use": "@vercel/static"
+    }
+  ],
+  "routes": [
+    {
+      "src": "/(.*)",
+      "dest": "/dashboard/$1"
+    }
+  ]
+}