Comprehensive Refinement Cycle v2.6: Security, Performance, and Training Quality

.gitignore

@@ -31,3 +31,8 @@ local_finetuned_model/
 # OS
 .DS_Store
 Thumbs.db
+
+# Frontend
+node_modules/
+dist/
+.next/

execution/fastapi_server.py

@@ -1,9 +1,12 @@
 import os
 import shutil
+import sys
+import json
 from dotenv import load_dotenv
-from fastapi import FastAPI, UploadFile, File, BackgroundTasks, HTTPException, Depends, Header, status
+from fastapi import FastAPI, UploadFile, File, BackgroundTasks, HTTPException, Depends, Header, status, Request, Query
 from fastapi.staticfiles import StaticFiles
 from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
 from pydantic import BaseModel
 import zipfile
 import rarfile
@@ -17,16 +20,39 @@ load_dotenv()
 from execution.feature_extractor import extract_features
 from execution.ensemble_manager import get_combined_verdict
 
-app = FastAPI(title="ConfereAI Audio Fraud Detection API")
+# Configurações de Segurança e Limites
+ADMIN_TOKEN = os.environ.get("ADMIN_TOKEN", "confereai_admin_token_2026")
+UPLOAD_MAX_SIZE = 10 * 1024 * 1024  # 10MB para análises comuns
+ALLOWED_ORIGINS = os.environ.get("ALLOWED_ORIGINS", "*").split(",")
 
-# Configuração de CORS
+app = FastAPI(title="ConfereAI Audio Fraud Detection API", version="2.6")
+
+# Configuração de CORS Dinâmica
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],
+    allow_origins=ALLOWED_ORIGINS,
+    allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
 )
 
+# --- MIDDLEWARE DE TAMANHO DE UPLOAD ---
+from fastapi import Request
+from fastapi.responses import JSONResponse
+
+@app.middleware("http")
+async def limit_upload_size(request: Request, call_next):
+    # O limite de 10MB não se aplica às rotas de admin (datasets são maiores)
+    if request.method == "POST" and not request.url.path.startswith("/admin"):
+        if "content-length" in request.headers:
+            if int(request.headers["content-length"]) > UPLOAD_MAX_SIZE:
+                return JSONResponse(
+                    status_code=413,
+                    content={"error": "Arquivo muito grande para análise. Limite de 10MB."}
+                )
+    return await call_next(request)
+# ---------------------------------------
+
 # Estado global do treinamento (simplificado para MVP)
 training_status = {
     "status": "idle", # idle, processing, training, completed, failed
@@ -35,14 +61,13 @@ training_status = {
     "error": None
 }
 
-# Verificador de token super simples
+# Verificador de token usando variável de ambiente
 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":
+    if token != ADMIN_TOKEN:
         raise HTTPException(status_code=401, detail="Token inválido")
     return token
 
@@ -118,7 +143,8 @@ class LoginRequest(BaseModel):
 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"}
+        # Correção Crítica: Retornar o token real configurado e não uma string fixa
+        return {"token": ADMIN_TOKEN}
     raise HTTPException(status_code=401, detail="Senha incorreta")
 
 @app.post("/admin/upload_dataset")

execution/inference_wav2vec.py

@@ -12,6 +12,33 @@ LOCAL_MODEL_DIR = "./local_finetuned_model"
 CUSTOM_MODEL_REPO = os.environ.get("CUSTOM_MODEL_REPO", "TEDDyx86/confereai-wav2vec2")
 BASE_MODEL = "HyperMoon/wav2vec2-base-960h-finetuned-deepfake"
 
+# Singleton para carregar o modelo e processador apenas uma vez
+_feature_extractor = None
+_model = None
+_last_model_path = None
+
+def get_wav2vec_resources(model_path):
+    global _feature_extractor, _model, _last_model_path
+    
+    # Invalidação de Cache: Se o path mudou, precisamos recarregar o modelo
+    if _feature_extractor is None or _model is None or _last_model_path != model_path:
+        print(f"Carregando motor Wav2Vec2 (HyperMoon): {model_path}...", file=sys.stderr)
+        _feature_extractor = AutoFeatureExtractor.from_pretrained(model_path)
+        model = AutoModelForAudioClassification.from_pretrained(model_path)
+        
+        # --- OTIMIZAÇÃO: Quantização Dinâmica para CPU ---
+        if not torch.cuda.is_available():
+            print("Aplicando Quantização Dinâmica (CPU Optimization)...", file=sys.stderr)
+            model = torch.quantization.quantize_dynamic(
+                model, {torch.nn.Linear}, dtype=torch.qint8
+            )
+        
+        _model = model
+        _model.eval()
+        _last_model_path = model_path
+        
+    return _feature_extractor, _model
+
 def run_inference(audio_path, fallback_model_name=None):
     """
     Realiza inferência real priorizando o modelo fine-tuned.
@@ -27,20 +54,9 @@ def run_inference(audio_path, fallback_model_name=None):
     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)
-        
-        # --- OTIMIZAÇÃO: Quantização Dinâmica para CPU ---
-        # Reduz o tamanho do modelo e acelera inferência em CPU (Hugging Face)
-        if not torch.cuda.is_available():
-            print("Aplicando Quantização Dinâmica (CPU Optimization)...", file=sys.stderr)
-            model = torch.quantization.quantize_dynamic(
-                model, {torch.nn.Linear}, dtype=torch.qint8
-            )
-        
-        model.eval()
+        # 1. Carrega extrator de características e modelo (Singleton)
+        feature_extractor, model = get_wav2vec_resources(model_path)
+
         
         # 2. Carrega e pré-processa o áudio
         print(f"Lendo áudio: {audio_path}", file=sys.stderr)

execution/metadata_extractor.py

@@ -1,20 +1,42 @@
+import librosa
+import os
 import sys
 import json
+from datetime import datetime
 
 def extract_metadata(file_path):
     """
-    Extrai metadados básicos de um arquivo de áudio.
+    Extrai metadados reais de um arquivo de áudio usando librosa.
     """
-    # 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
+    try:
+        # Carrega apenas os metadados (duration) sem ler todo o áudio se possível
+        # librosa.get_duration é eficiente
+        duration = librosa.get_duration(path=file_path)
+        
+        # Para taxa de amostragem e canais, carregamos um pequeno trecho
+        y, sr = librosa.load(file_path, sr=None, duration=0.1)
+        channels = 1 if len(y.shape) == 1 else y.shape[0]
+        
+        # Informações do arquivo
+        file_stats = os.stat(file_path)
+        creation_time = datetime.fromtimestamp(file_stats.st_ctime).strftime('%Y-%m-%d %H:%M:%S')
+        file_format = os.path.splitext(file_path)[1].replace('.', '').upper()
+        
+        metadata = {
+            "format": file_format,
+            "sample_rate": sr,
+            "channels": channels,
+            "duration_seconds": round(duration, 2),
+            "encoder": "Librosa Forensic Parser",
+            "creation_time": creation_time
+        }
+        return metadata
+    except Exception as e:
+        print(f"Erro ao extrair metadados: {e}")
+        return {
+            "format": "Unknown",
+            "error": str(e)
+        }
 
 if __name__ == "__main__":
     if len(sys.argv) < 2:

execution/train_wav2vec.py

@@ -72,9 +72,19 @@ def start_finetuning(dataset_dir: str):
     """
     processor = get_processor()
     
-    # Prepara os datasets (simplificação: usando o mesmo para train e eval na V1)
-    train_dataset = DeepfakeAudioDataset(dataset_dir, processor)
+    # Prepara os datasets com split de 80/20 para avaliação real
+    full_dataset = DeepfakeAudioDataset(dataset_dir, processor)
     
+    if len(full_dataset) < 10:
+        print("⚠️ Dataset muito pequeno. Usando todo o conjunto para treino e eval.")
+        train_dataset = full_dataset
+        eval_dataset = full_dataset
+    else:
+        train_size = int(0.8 * len(full_dataset))
+        eval_size = len(full_dataset) - train_size
+        train_dataset, eval_dataset = torch.utils.data.random_split(full_dataset, [train_size, eval_size])
+        print(f"📊 Dataset dividido: {train_size} para treino, {eval_size} para avaliação.")
+        
     if len(train_dataset) == 0:
         raise ValueError("Nenhum áudio encontrado no dataset.")
         
@@ -119,7 +129,7 @@ def start_finetuning(dataset_dir: str):
         model=model,
         args=training_args,
         train_dataset=train_dataset,
-        eval_dataset=train_dataset, # Idealmente, devíamos fazer um split de 80/20
+        eval_dataset=eval_dataset, # Agora usando o split real de 20%
     )
     
     trainer.train()