Update app.py

app.py

@@ -1,180 +1,159 @@
+# ---------------------------------------------------------
+#  app.py — Twin-Branch A–M Reasoning Demo (Gemma 3n)
+#  Carlos Rodrigues — 2025
+# ---------------------------------------------------------
+
+import torch
 import gradio as gr
+from huggingface_hub import snapshot_download
+from transformers import AutoTokenizer, AutoModelForCausalLM
 import os
-import json
-from pathlib import Path
 from datetime import datetime
-
-try:
-    from llama_cpp import Llama
-    LLM_AVAILABLE = True
-except Exception as e:
-    LLM_AVAILABLE = False
-    _err = str(e)
-
-
-# ==========================
-# CONFIG
-# ==========================
-MODEL_PATH = os.environ.get("MODEL_PATH", "models/gemma-2-2b-it-Q4_K_M.gguf")
-
-TEMP_A = 0.0     # deterministic
-TEMP_M = 0.9     # exploratory
-TOP_P = 0.95
-MAX_TOKENS = 256
-
-
-# ==========================
-# UTILITIES
-# ==========================
-
-def load_llm():
-    if not LLM_AVAILABLE:
-        return None
-    return Llama(
-        model_path=MODEL_PATH,
-        n_ctx=4096,
-        n_threads=8,
-        verbose=False
-    )
-
-
-llm = load_llm()
-
-def generate(prompt, temperature):
-    if not LLM_AVAILABLE or llm is None:
-        return f"(LLM não disponível: {_err})"
-
-    out = llm.create_completion(
-        prompt=prompt,
-        temperature=temperature,
-        max_tokens=MAX_TOKENS,
-        top_p=TOP_P
-    )
-    return out["choices"][0]["text"].strip()
-
+import re
+
+# ---------------------------------------------------------
+# CONFIGURAÇÃO DO MODELO (troque aqui se quiser outro)
+# ---------------------------------------------------------
+
+MODEL_REPO = "google/gemma-3n-E2B-it-litert-lm"
+
+LOCAL_MODEL_DIR = snapshot_download(
+    repo_id=MODEL_REPO,
+    allow_patterns=["*.json", "*.bin", "*.model", "*.safetensors", "*.txt"],
+)
+
+# ---------------------------------------------------------
+# CARREGAR TOKENIZER & MODELO
+# ---------------------------------------------------------
+
+tokenizer = AutoTokenizer.from_pretrained(LOCAL_MODEL_DIR)
+
+model = AutoModelForCausalLM.from_pretrained(
+    LOCAL_MODEL_DIR,
+    torch_dtype=torch.float32,
+    device_map="auto"   # usa GPU se tiver
+)
+
+# ---------------------------------------------------------
+# FUNÇÕES AUXILIARES
+# ---------------------------------------------------------
+
+def clean_text(t):
+    t = t.replace("<s>", "").replace("</s>", "")
+    t = re.sub(r"\s+", " ", t)
+    return t.strip()
+
+def generate_answer(prompt, temperature=0.0, top_p=1.0, max_new_tokens=180):
+    inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
+    with torch.no_grad():
+        output = model.generate(
+            **inputs,
+            max_new_tokens=max_new_tokens,
+            temperature=temperature,
+            top_p=top_p,
+            do_sample=temperature > 0
+        )
+    decoded = tokenizer.decode(output[0])
+    return clean_text(decoded.replace(prompt, ""))
 
 def divergence(a, b):
-    if not a or not b:
+    """
+    Divergência simples: token overlap (0=igual, 1=muito diferente)
+    """
+    sa, sb = a.split(), b.split()
+    if len(sa) == 0 or len(sb) == 0:
         return 1.0
-    wa = set(a.split())
-    wb = set(b.split())
-    inter = wa & wb
-    union = wa | wb
-    if not union:
-        return 1.0
-    return round(1 - len(inter)/len(union), 3)
-
+    common = len(set(sa) & set(sb))
+    union = len(set(sa) | set(sb))
+    sim = common / union
+    return round(1 - sim, 3)
 
-# ==========================
-# DATASET SAVE
-# ==========================
+# ---------------------------------------------------------
+# PIPELINE A–M
+# ---------------------------------------------------------
 
-SAVE_DIR = Path("outputs")
-SAVE_DIR.mkdir(exist_ok=True)
+def twin_branch_pipeline(question):
+    timestamp = datetime.utcnow().isoformat() + "Z"
 
-def save_dataset(question, respA, respM, div_score):
-    timestamp = datetime.utcnow().isoformat()
-    base = SAVE_DIR / f"dataset_{timestamp}"
+    prompt = f"Pergunta: {question}\nResponda claramente em até 120 palavras:\n"
 
-    md_path = base.with_suffix(".md")
-    json_path = base.with_suffix(".json")
-
-    # Markdown
-    md = f"""
-# Registro A-M
-Gerado: {timestamp}
+    # A — determinístico
+    answer_A = generate_answer(prompt, temperature=0.0, top_p=1.0)
 
-## Pergunta
-{question}
+    # M — exploratório (descobre divergências)
+    answer_M = generate_answer(prompt, temperature=0.9, top_p=0.95)
 
-## Resposta A (determinística)
-{respA}
+    # Divergência
+    div_score = divergence(answer_A, answer_M)
 
-## Resposta M (exploratória)
-{respM}
+    # Decisão simples
+    if div_score < 0.15:
+        decision = "Ambas respostas convergem — usar Resposta A."
+    elif div_score < 0.40:
+        decision = "Diferença moderada — sugerir resposta A, mas avisar ambiguidade."
+    elif div_score < 0.75:
+        decision = "As respostas divergem — investigar as duas interpretações."
+    else:
+        decision = "Alta divergência — perguntar ao operador para sanear intenção."
 
-### Divergência
-{div_score}
-"""
-
-    md_path.write_text(md, encoding="utf-8")
-
-    # JSON
-    data = {
+    # Retorno estruturado
+    return {
         "timestamp": timestamp,
         "question": question,
-        "response_A": respA,
-        "response_M": respM,
-        "divergence": div_score
+        "A (determinística)": answer_A,
+        "M (exploratória)": answer_M,
+        "Divergência (0=igual,1=muito diferente)": div_score,
+        "Decisão da Máquina": decision
     }
 
-    json_path.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
-
-    return str(md_path), str(json_path)
+# ---------------------------------------------------------
+# INTERFACE GRADIO
+# ---------------------------------------------------------
 
+def run_interface(question):
+    result = twin_branch_pipeline(question)
 
-# ==========================
-# GRADIO UI
-# ==========================
-
-def run(question):
-    if not question.strip():
-        return ["", "", "", ""]
-
-    prompt = f"Pergunta: {question}\nResponda de forma direta:"
-
-    respA = generate(prompt, TEMP_A)
-    respM = generate(prompt, TEMP_M)
-    div_score = divergence(respA, respM)
-
-    return respA, respM, str(div_score), ""
-
+    md = f"""
+# 🔎 Twin-Reasoning A–M (Gemma-3n E2B)
 
-def save_btn(question, respA, respM, div_score):
-    if not question or not respA:
-        return "Nada para salvar."
+**Pergunta:**  
+{result['question']}
 
-    md_path, json_path = save_dataset(question, respA, respM, div_score)
-    return f"Salvo!\nMD: {md_path}\nJSON: {json_path}"
+---
 
+## 🟦 Resposta A (determinística)
+{result['A (determinística)']}
 
-with gr.Blocks(title="A-M Divergence Generator (Gemma 2B)") as demo:
+## 🟧 Resposta M (exploratória)
+{result['M (exploratória)']}
 
-    gr.Markdown("""
-    # 🔵 A-M Divergence Generator  
-    Gera **duas respostas** usando o mesmo modelo Gemma:
+---
 
-    - **A** → Determinística (Temperature 0.0)  
-    - **M** → Exploratório (Temperature 0.9)  
-    - Mostra divergência → Se ≈0 = iguais, se ≈1 = totalmente diferentes  
-    - Permite salvar dataset `.md` + `.json` automaticamente  
-    """)
+### 📊 Divergência
+**{result['Divergência (0=igual,1=muito diferente)']}**
 
-    with gr.Row():
-        question = gr.Textbox(label="Pergunta", placeholder="Digite sua pergunta aqui...", lines=3)
+### 🧭 Decisão Interna
+**{result['Decisão da Máquina']}**
 
-    run_btn = gr.Button("Gerar A / M")
-    
-    with gr.Row():
-        respA = gr.Textbox(label="Resposta A (determinística)")
-        respM = gr.Textbox(label="Resposta M (exploratória)")
+---
 
-    div = gr.Textbox(label="Divergência (0 = igual, 1 = totalmente diferente)")
+*Gerado em:* `{result['timestamp']}`
+    """
 
-    status = gr.Textbox(label="Status / Logs")
+    return md
 
-    save = gr.Button("Salvar como Dataset (.md + .json)")
 
-    run_btn.click(
-        fn=run,
-        inputs=[question],
-        outputs=[respA, respM, div, status]
-    )
+# ---------------------------------------------------------
+# LANÇAR A APP
+# ---------------------------------------------------------
 
-    save.click(
-        fn=save_btn,
-        inputs=[question, respA, respM, div],
-        outputs=[status]
-    )
+demo = gr.Interface(
+    fn=run_interface,
+    inputs=gr.Textbox(label="Digite uma pergunta:", placeholder="Ex: É legítimo filmar alguém em via pública?"),
+    outputs=gr.Markdown(),
+    title="Twin-Reasoner A–M — Gemma 3n",
+    description="Simulador de Arquitetura A–M (Geração + Verificação) baseado em pesos congelados.",
+)
 
-demo.launch()
+if __name__ == "__main__":
+    demo.launch()