fix: Reverter motor para a versão estável pré-motor pessoal (v2.7)

execution/ensemble_manager.py

@@ -11,65 +11,47 @@ def get_combined_verdict(file_path):
     
     # 2. Executa Motor 2 (AST - Espectrograma e Frequência)
     res_ast = run_ast(file_path)
-    
-    # 1. Extração de scores brutos
-    # Se houver erro em algum motor, o score padrão é 0.0, mas o veredito deve refletir o erro
-    has_error = False
-    error_msg = ""
-    
-    if "error" in res_w2v:
-        has_error = True
-        error_msg += f"Wav2Vec2 Error: {res_w2v['error']}. "
-    
-    if "error" in res_ast:
-        # Erro no AST não é fatal, usamos apenas W2V se possível
-        print(f"AST Warning: {res_ast['error']}")
-
-    score_w2v = res_w2v.get("deepfake_probability", 0.0)
     score_ast = res_ast.get("risk_score", 0.0)
     
-    # 2. Pesos do Ensemble (Protocolo de Rigor)
-    # Aumentamos o peso do Wav2Vec2 para 0.8 pois o HyperMoon é mais específico para Deepfakes
-    # O AST serve como um "sanity check" de anomalias acústicas
-    WEIGHT_W2V = 0.8
-    WEIGHT_AST = 0.2
+    # 3. Lógica do Protocolo de Rigor V3 (Soberania HyperMoon)
+    # O motor Wav2Vec2 (HyperMoon) é o comandante principal (70% do peso)
+    
+    # Pesos definidos para dar comando ao HyperMoon
+    WEIGHT_W2V = 0.7
+    WEIGHT_AST = 0.3
     
-    # 3. Cálculo do Score Final
+    # Cálculo ponderado do score
     final_score = (score_w2v * WEIGHT_W2V) + (score_ast * WEIGHT_AST)
     
-    # 4. Lógica de Decisão Rigorosa (Protocolo de Rigor V5)
-    # Aumentamos a sensibilidade: qualquer sinal forte de fraude em um dos motores ou um consenso moderado dispara o alerta.
-    SPOOF_THRESHOLD = 0.35  # Sensibilidade aumentada (antes 0.42)
+    # Thresholds de decisão
+    SPOOF_THRESHOLD = 0.50
+    HIGH_CONFIDENCE = 0.85
     
+    is_fraud = False
     verdict = "AUTHENTIC"
     
-    # Critérios de Decisão:
-    # 1. Soberania Wav2Vec2: Se o modelo especializado detectar > 45% de chance de fraude.
-    # 2. Consenso Ponderado: Se a média ponderada ultrapassar o threshold de rigor.
-    # 3. Alerta de Anomalia AST: Se o AST detectar risco extremo (> 80%), mesmo que o W2V esteja em dúvida.
-    
-    if has_error and score_w2v == 0.0:
-        verdict = "ERROR"
-    elif score_w2v > 0.45:
-        verdict = "SPOOF" # Detecção direta pelo motor principal
+    # Lógica de decisão baseada na confiança do comandante (HyperMoon)
+    if score_w2v >= HIGH_CONFIDENCE:
+        is_fraud = True
+        verdict = "SPOOF"
+        message = "COMANDO HYPERMOON: Detecção crítica de padrões neurais sintéticos com alta convicção."
     elif final_score >= SPOOF_THRESHOLD:
-        verdict = "SPOOF" # Detecção por consenso de ensemble
-    elif score_ast > 0.85:
-        verdict = "SPOOF" # Anomalia acústica crítica detectada
-    
-    # 5. Formatação da Resposta
+        is_fraud = True
+        verdict = "SPOOF"
+        message = f"ALERTA COMBINADO: Risco de {(final_score*100):.1f}% identificado, com base na análise espectral e fonética."
+    else:
+        message = "INTEGRIDADE CONFIRMADA: Padrões de voz condizentes com gravação humana autêntica."
+        
     return {
         "verdict": verdict,
         "fraud_probability": final_score,
         "wav2vec_score": score_w2v,
         "ast_score": score_ast,
-        "temporal_scores": res_w2v.get("temporal_scores", []),
-        "engines_consensus": f"Rigor V5: {int(WEIGHT_W2V*100)}% W2V / {int(WEIGHT_AST*100)}% AST",
-        "error": error_msg if has_error else None,
+        "temporal_scores": res_w2v.get("temporal_scores", []), 
+        "engines_consensus": message,
         "details": {
-            "protocol": "Protocolo de Rigor V5 (Forense de Alta Sensibilidade)",
-            "weights": {"wav2vec": WEIGHT_W2V, "ast": WEIGHT_AST},
-            "threshold": SPOOF_THRESHOLD
+            "protocol": "Protocolo de Rigor V3 (Soberania HyperMoon)",
+            "weights": {"wav2vec": WEIGHT_W2V, "ast": WEIGHT_AST}
         },
         "engines": ["HyperMoon-Wav2Vec2", "AST-Spectrogram"]
     }

execution/fastapi_server.py

@@ -12,10 +12,6 @@ import zipfile
 import rarfile
 import uuid
 import uvicorn
-import secrets
-from slowapi import Limiter, _rate_limit_exceeded_handler
-from slowapi.util import get_remote_address
-from slowapi.errors import RateLimitExceeded
 
 # Carrega variáveis do arquivo .env
 load_dotenv()
@@ -25,14 +21,7 @@ from execution.feature_extractor import extract_features
 from execution.ensemble_manager import get_combined_verdict
 
 # Configurações de Segurança e Limites
-ADMIN_TOKEN = os.environ.get("ADMIN_TOKEN")
-if not ADMIN_TOKEN:
-    # Gera um token aleatório e seguro caso não esteja no .env (Hardening)
-    ADMIN_TOKEN = secrets.token_urlsafe(32)
-    print(f"\n[SECURITY WARNING] ADMIN_TOKEN não configurado no ambiente.")
-    print(f"[SECURITY WARNING] Token gerado dinamicamente: {ADMIN_TOKEN}\n")
-
-limiter = Limiter(key_func=get_remote_address)
+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(",")
 
@@ -46,24 +35,15 @@ app.add_middleware(
     allow_methods=["*"],
     allow_headers=["*"],
 )
-app.state.limiter = limiter
-app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)
 
-# --- MIDDLEWARE E ARQUIVOS ESTÁTICOS ---
+# --- MIDDLEWARE DE TAMANHO DE UPLOAD ---
 from fastapi import Request
 from fastapi.responses import JSONResponse
 
-# Garante que o diretório .tmp existe
-if not os.path.exists(".tmp"):
-    os.makedirs(".tmp")
-
-# Monta o diretório .tmp para servir os espectrogramas gerados
-app.mount("/tmp", StaticFiles(directory=".tmp"), name="tmp")
-
 @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") and request.url.path == "/analyze":
+    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(
@@ -122,8 +102,7 @@ class AnalysisResult(BaseModel):
     temporal_scores: list = []
 
 @app.post("/analyze", response_model=AnalysisResult)
-@limiter.limit("5/minute")
-async def analyze_audio_endpoint(request: Request, background_tasks: BackgroundTasks, file: UploadFile = File(...)):
+async def analyze_audio_endpoint(background_tasks: BackgroundTasks, file: UploadFile = File(...)):
     # Validação rigorosa de extensão
     ALLOWED_EXTENSIONS = {'.wav', '.mp3', '.flac', '.ogg', '.m4a', '.aac'}
     ext = os.path.splitext(file.filename)[1].lower()
@@ -152,19 +131,19 @@ async def analyze_audio_endpoint(request: Request, background_tasks: BackgroundT
         # 2. Inferência via Ensemble (Wav2Vec2 + AST)
         analysis = get_combined_verdict(file_path)
         
-        # 3. Agenda limpeza em background (após 10 minutos para dar tempo do front ler a imagem)
+        # 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(600) # 10 minutos
+            time.sleep(300) # 5 minutos
             for p in paths:
-                if p and os.path.exists(p):
+                if os.path.exists(p):
                     try:
                         os.remove(p)
-                    except: pass
+                        print(f"Cleanup: {p} removido.")
+                    except Exception as e:
+                        print(f"Cleanup error: {e}")
 
-        # O spectrogram_path vem de features
-        spec_local_path = features.get("spectrogram_path")
-        background_tasks.add_task(cleanup_temp_files, [file_path, spec_local_path])
+        background_tasks.add_task(cleanup_temp_files, [file_path, features.get("spectrogram_path")])
 
         # 4. Resposta Consolidada
         return AnalysisResult(
@@ -172,7 +151,7 @@ async def analyze_audio_endpoint(request: Request, background_tasks: BackgroundT
             fraud_score=analysis.get("fraud_probability", 0.0),
             verdict=analysis.get("verdict", "UNKNOWN"),
             spectrogram_url=features.get("spectrogram_path", "").replace(".tmp/", "/tmp/"),
-            engine="HyperMoon Ensemble v2 (Wav2Vec2 + AST)",
+            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", ""),
@@ -181,11 +160,7 @@ async def analyze_audio_endpoint(request: Request, background_tasks: BackgroundT
 
     except Exception as e:
         print(f"Erro na análise: {e}")
-        # Tratamento de erro amigável (Production Ready)
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail="Não foi possível processar este arquivo de áudio. Verifique se o arquivo não está corrompido ou protegido por DRM."
-        )
+        raise e
 
 # --- ADMIN ENDPOINTS ---
 

execution/inference_wav2vec.py

@@ -8,7 +8,7 @@ from transformers import AutoFeatureExtractor, AutoModelForAudioClassification
 import os
 
 LOCAL_MODEL_DIR = "./local_finetuned_model"
-# Prioridade: 1. Pasta Local | 2. Variável de Ambiente | 3. Modelo Base Estável
+# Prioridade: 1. Pasta Local (Upload direto) | 2. Repo Customizado (Variável de Ambiente) | 3. Modelo Base
 CUSTOM_MODEL_REPO = os.environ.get("CUSTOM_MODEL_REPO", None)
 BASE_MODEL = "HyperMoon/wav2vec2-base-960h-finetuned-deepfake"
 
@@ -26,13 +26,17 @@ def get_wav2vec_resources(model_path):
         _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
         
-        # Log para depuração de labels
-        print(f"Mapeamento de Labels: {model.config.id2label}", file=sys.stderr)
-        
     return _feature_extractor, _model
 
 def run_inference(audio_path, fallback_model_name=None):