Create app.py

app.py

@@ -0,0 +1,253 @@
+import gradio as gr
+import torch
+import torch.nn.functional as F
+import os
+import sys
+from transformers import AutoModelForMaskedLM, AutoTokenizer
+from sentence_transformers import SentenceTransformer
+from huggingface_hub import hf_hub_download
+
+# Importa a classe real do seu arquivo bettina.py
+# Certifique-se de que bettina.py está na mesma pasta
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+try:
+    from bettina import VortexBetinaAntiHalluc
+except ImportError:
+    # Tenta importar assumindo que estamos na raiz do projeto
+    try:
+        import bettina
+        VortexBetinaAntiHalluc = bettina.VortexBetinaAntiHalluc
+    except ImportError as e:
+        raise ImportError(f"CRÍTICO: Não foi possível encontrar 'bettina.py'. Verifique se o arquivo foi enviado para o Space. Erro: {e}")
+
+# Configuração de Dispositivo
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+print(f"Rodando em: {device}")
+
+# ==============================================================================
+# 1. Carregamento dos Modelos Base
+# ==============================================================================
+print("Carregando modelos base...")
+embedding_model_name = "sentence-transformers/paraphrase-multilingual-mpnet-base-v2"
+tokenizer_name = "neuralmind/bert-base-portuguese-cased"
+
+# Carrega modelos com cache para não baixar toda vez
+embedding_model = SentenceTransformer(embedding_model_name, device=str(device))
+tokenizer = AutoTokenizer.from_pretrained(tokenizer_name)
+mlm_model = AutoModelForMaskedLM.from_pretrained(tokenizer_name).to(device)
+mlm_model.eval()
+
+# ==============================================================================
+# 2. Inicialização da Betina (Nosso Cérebro)
+# ==============================================================================
+# Configurações devem bater com o que foi treinado. Usando defaults do bettina.py
+EMBED_DIM = 256
+RAW_EMBED_DIM = embedding_model.get_sentence_embedding_dimension() # 768
+HIDDEN_SIZE = mlm_model.config.hidden_size # 768
+
+print("Inicializando Vortex Betina...")
+# Instancia a classe robusta do seu código
+vortex = VortexBetinaAntiHalluc(
+    embed_dim=EMBED_DIM,
+    # Habilitando recursos avançados por padrão para demonstração
+    enable_rotation=True,
+    enable_quadratic_reflection=True,
+    enable_lorentz_transform=True,
+    enforce_square_geometry=True
+).to(device)
+
+# Projetores para conectar os mundos (SentenceTransformer -> Vortex -> BERT)
+embedding_projector = torch.nn.Linear(RAW_EMBED_DIM, EMBED_DIM).to(device)
+correction_projector = torch.nn.Linear(EMBED_DIM, HIDDEN_SIZE).to(device)
+
+# ==============================================================================
+# 3. Carregamento de Pesos (Se existirem)
+# ==============================================================================
+weights_loaded = False
+REPO_ID = "reynaldo22/betina-perfect-2025"
+
+# 1. Tentar baixar do Hugging Face Hub
+try:
+    print(f"Tentando baixar pesos do repositório: {REPO_ID}...")
+    token = os.getenv("HF_TOKEN")
+    vortex_path = hf_hub_download(repo_id=REPO_ID, filename="vortex.pt", token=token)
+    emb_path = hf_hub_download(repo_id=REPO_ID, filename="embedding_projector.pt", token=token)
+    corr_path = hf_hub_download(repo_id=REPO_ID, filename="correction_projector.pt", token=token)
+    
+    # strict=False permite carregar pesos parciais se houver pequenas diferenças de versão
+    vortex.load_state_dict(torch.load(vortex_path, map_location=device), strict=False)
+    embedding_projector.load_state_dict(torch.load(emb_path, map_location=device))
+    correction_projector.load_state_dict(torch.load(corr_path, map_location=device))
+    weights_loaded = True
+    print("✅ Pesos carregados do Hugging Face com sucesso!")
+except Exception as e:
+    print(f"⚠️ Falha ao baixar do Hugging Face: {e}")
+    print("Tentando carregar localmente...")
+
+# 2. Fallback para arquivos locais
+if not weights_loaded:
+    POSSIBLE_DIRS = ["outputs/betina_vortex", ".", "model_weights"]
+    for model_dir in POSSIBLE_DIRS:
+        vortex_path = os.path.join(model_dir, "vortex.pt")
+        if os.path.exists(vortex_path):
+            print(f"Carregando pesos locais de {model_dir}...")
+            try:
+                vortex.load_state_dict(torch.load(vortex_path, map_location=device))
+                embedding_projector.load_state_dict(torch.load(os.path.join(model_dir, "embedding_projector.pt"), map_location=device))
+                correction_projector.load_state_dict(torch.load(os.path.join(model_dir, "correction_projector.pt"), map_location=device))
+                weights_loaded = True
+                break
+            except Exception as e:
+                print(f"Erro ao carregar pesos de {model_dir}: {e}")
+
+if not weights_loaded:
+    print("⚠️ AVISO: Pesos treinados não encontrados. Usando inicialização aleatória.")
+    print("O modelo vai rodar, mas as respostas da Betina serão aleatórias até você treinar.")
+
+vortex.eval()
+embedding_projector.eval()
+correction_projector.eval()
+
+# ==============================================================================
+# 4. Lógica de Inferência
+# ==============================================================================
+def predict(contexto, frase_mask):
+    if "[MASK]" not in frase_mask:
+        return "⚠️ Erro: A frase precisa conter o token [MASK]."
+
+    # Combinar contexto e frase para o embedding semântico
+    texto_completo = f"{contexto} {frase_mask}".strip()
+    
+    # Preparar inputs para o BERT
+    inputs = tokenizer(texto_completo, return_tensors="pt").to(device)
+    
+    # Encontrar índice da máscara
+    mask_token_index = (inputs.input_ids == tokenizer.mask_token_id)[0].nonzero(as_tuple=True)[0]
+    if len(mask_token_index) == 0:
+         return "Erro: Token [MASK] não identificado corretamente pelo tokenizer."
+    mask_idx = mask_token_index[0].item()
+
+    # --- 1. BERT Puro (Baseline) ---
+    with torch.no_grad():
+        outputs_base = mlm_model(**inputs)
+        logits_base = outputs_base.logits
+        probs_base = F.softmax(logits_base[0, mask_idx], dim=-1)
+        top_k_base = torch.topk(probs_base, 5)
+        
+        res_base = []
+        for idx, score in zip(top_k_base.indices, top_k_base.values):
+            token = tokenizer.decode([idx]).strip()
+            res_base.append(f"**{token}** ({score:.2%})")
+
+    # --- 2. Betina (Com Vórtice) ---
+    with torch.no_grad():
+        # a) Gerar embedding semântico do texto todo
+        emb = embedding_model.encode(texto_completo, convert_to_tensor=True).to(device)
+        
+        # b) Projetar para dimensão do Vórtice
+        proj = embedding_projector(emb)
+        
+        # c) Passar pelo Vórtice (O Cérebro Caótico)
+        # O método forward retorna: evolved, loss, metrics, delta_inter
+        # Precisamos adicionar dimensão de batch (unsqueeze)
+        _, _, metrics, delta = vortex(proj.unsqueeze(0)) 
+        
+        # d) Projetar correção de volta para dimensão do BERT
+        correction = correction_projector(delta).unsqueeze(1) # [1, 1, hidden_size]
+        
+        # e) Injetar nos hidden states do BERT
+        outputs_hidden = mlm_model(**inputs, output_hidden_states=True)
+        last_hidden_state = outputs_hidden.hidden_states[-1]
+        
+        # Soma a correção (broadcast)
+        corrected_hidden = last_hidden_state + correction
+        
+        # f) Predição final
+        if hasattr(mlm_model, "cls"):
+            logits_betina = mlm_model.cls(corrected_hidden)
+        else:
+            logits_betina = mlm_model.get_output_embeddings()(corrected_hidden)
+            
+        probs_betina = F.softmax(logits_betina[0, mask_idx], dim=-1)
+        top_k_betina = torch.topk(probs_betina, 5)
+        
+        res_betina = []
+        for idx, score in zip(top_k_betina.indices, top_k_betina.values):
+            token = tokenizer.decode([idx]).strip()
+            res_betina.append(f"**{token}** ({score:.2%})")
+
+    # Formatar saída HTML
+    html_output = f"""
+    <div style="display: flex; gap: 20px; flex-wrap: wrap;">
+        <div style="flex: 1; min-width: 300px; background-color: #f5f5f5; padding: 15px; border-radius: 10px; border: 1px solid #ddd;">
+            <h3 style="color: #555; margin-top: 0;">🧠 BERT Padrão</h3>
+            <p style="font-size: 0.9em; color: #666;"><i>O que o modelo "decorou" do treino original.</i></p>
+            <ol>
+                {''.join([f'<li>{item}</li>' for item in res_base])}
+            </ol>
+        </div>
+        <div style="flex: 1; min-width: 300px; background-color: #e6f7ff; padding: 15px; border-radius: 10px; border: 2px solid #1890ff;">
+            <h3 style="color: #0050b3; margin-top: 0;">🌀 Betina 2.0</h3>
+            <p style="font-size: 0.9em; color: #0050b3;"><i>Influenciado pelo Vórtice e Contexto.</i></p>
+            <ol>
+                {''.join([f'<li>{item}</li>' for item in res_betina])}
+            </ol>
+        </div>
+    </div>
+    <br>
+    <details>
+        <summary style="cursor: pointer; color: #888;">📊 Métricas do Vórtice (Estado Interno)</summary>
+        <pre style="font-size: 0.8em; background: #333; color: #0f0; padding: 10px; border-radius: 5px; overflow-x: auto;">{str(metrics)}</pre>
+    </details>
+    """
+    return html_output
+
+# ==============================================================================
+# 5. Interface Gradio
+# ==============================================================================
+custom_css = """
+footer {visibility: hidden}
+"""
+
+with gr.Blocks(title="Betina 2.0 - Anti-Hallucination AI") as demo:
+    gr.Markdown("""
+    # 🌀 Betina 2.0: Anti-Hallucination Vortex
+    
+    Esta interface demonstra o poder do **Vórtice Betina**, uma arquitetura híbrida que usa sistemas dinâmicos caóticos 
+    (Atrator de Lorenz, Rotação de Matrizes) para corrigir alucinações em modelos de linguagem.
+    
+    **Como funciona:** O modelo lê o contexto e a frase, passa por um "vórtice matemático" que simula pensamento dinâmico, 
+    e injeta uma correção vetorial diretamente nos neurônios do BERT antes dele responder.
+    """)
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            txt_contexto = gr.Textbox(
+                label="1. Contexto / Fato (A Verdade)", 
+                placeholder="Ex: O céu neste planeta alienígena é verde limão.", 
+                lines=3
+            )
+            txt_mask = gr.Textbox(
+                label="2. Frase para Completar (Use [MASK])", 
+                placeholder="Ex: Olhando para cima, vejo um céu [MASK].", 
+                lines=2
+            )
+            btn_run = gr.Button("🌀 Processar no Vórtice", variant="primary")
+            
+        with gr.Column(scale=1):
+            out_result = gr.HTML(label="Resultado Comparativo")
+    
+    gr.Markdown("### Exemplos Prontos")
+    gr.Examples(
+        examples=[
+            ["O céu é verde e o mar é roxo.", "A cor do céu é [MASK]."],
+            ["A capital do Brasil é Buenos Aires (neste universo alternativo).", "A capital do Brasil é [MASK]."],
+            ["Betina é uma IA que evita alucinações.", "O objetivo da Betina é evitar [MASK]."]
+        ],
+        inputs=[txt_contexto, txt_mask]
+    )
+
+    btn_run.click(fn=predict, inputs=[txt_contexto, txt_mask], outputs=out_result)
+
+if __name__ == "__main__":
+    demo.launch()