Update app.py

app.py

@@ -4,8 +4,20 @@ import torch.nn as nn
 import torch.nn.functional as F
 import gradio as gr
 import os
+import random
+import numpy as np
 
-# --- MISMOS HIPERPARÁMETROS ---
+# --- 1. DETERMINISMO TOTAL ---
+# Esto asegura que HF use la misma lógica matemática que tu PC
+def set_seed(seed=42):
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+
+set_seed(42)
+
+# --- CONFIGURACIÓN ---
 embed_size = 256
 num_heads = 4
 num_layers = 4
@@ -13,7 +25,7 @@ block_size = 256
 vocab_size = 256
 device = "cpu"
 
-# --- TU ARQUITECTURA ---
+# --- ARQUITECTURA ---
 class MiniGPT(nn.Module):
     def __init__(self, v_size):
         super().__init__()
@@ -21,8 +33,8 @@ class MiniGPT(nn.Module):
         self.pos_embedding = nn.Embedding(block_size, embed_size)
         self.blocks = nn.ModuleList([
             nn.TransformerEncoderLayer(d_model=embed_size, nhead=num_heads, 
-                                       dim_feedforward=embed_size*4, batch_first=True, 
-                                       dropout=0.1, norm_first=True) 
+                                        dim_feedforward=embed_size*4, batch_first=True, 
+                                        dropout=0.1, norm_first=True) 
             for _ in range(num_layers)
         ])
         self.ln = nn.LayerNorm(embed_size)
@@ -30,45 +42,74 @@ class MiniGPT(nn.Module):
 
     def forward(self, idx, targets=None):
         B, T = idx.shape
+        # Limitamos el tamaño del bloque para evitar errores de índice
+        T = min(T, block_size)
+        idx = idx[:, -T:]
+        
         tok_emb = self.token_embedding(idx)
         pos = torch.arange(T, device=device)
         pos_emb = self.pos_embedding(pos)[None, :, :]
         x = tok_emb + pos_emb
+        
         mask = torch.triu(torch.ones(T, T, device=device), diagonal=1).bool()
-        for block in self.blocks: x = block(x, src_mask=mask)
+        for block in self.blocks: 
+            x = block(x, src_mask=mask)
+        
         x = self.ln(x)
         logits = self.fc_out(x)
         return logits, None
 
-# --- CARGAR EL MODELO ---
+# --- CARGA DEL MODELO ---
 model = MiniGPT(vocab_size).to(device)
 if os.path.exists("mini_gpt.pth"):
+    # Uso de weights_only=True por seguridad y compatibilidad
     model.load_state_dict(torch.load("mini_gpt.pth", map_location=device))
 model.eval()
 
-# --- FUNCIÓN DE RESPUESTA ---
+# --- FUNCIÓN DE RESPUESTA OPTIMIZADA ---
 def responder(mensaje, historial):
-    contexto = f"\nUsuario: {mensaje}\nIA: "
+    # Formateamos el prompt exactamente como en el entrenamiento
+    # Usamos marcas claras para que la IA sepa dónde empezar
+    contexto = f"### Human: {mensaje}\n### Assistant: "
     tokens = [ord(c) if ord(c) < 256 else 32 for c in contexto]
     ai_txt = ""
-    
+
     with torch.no_grad():
-        for _ in range(150):
+        for _ in range(100): # 100 caracteres es suficiente para CPU
             idx = torch.tensor([tokens[-block_size:]], dtype=torch.long).to(device)
             logits, _ = model(idx)
-            probs = F.softmax(logits[:, -1, :] / 0.8, dim=-1)
-            next_token = torch.multinomial(probs, num_samples=1).item()
+            
+            # --- GREEDY SEARCH (Cero azar) ---
+            # En lugar de multinomial, usamos argmax para que PC y HF sean gemelos
+            next_token = torch.argmax(logits[:, -1, :], dim=-1).item()
+            
             char = chr(next_token)
             
-            if char == "\n" or ai_txt.endswith("Usuario:"): break
+            # Frenado de emergencia si empieza a repetir el prompt
+            if char == "\n" and len(ai_txt) > 5: break
+            if "### Human:" in ai_txt: break
+            
             tokens.append(next_token)
             ai_txt += char
-            
-    return ai_txt.replace("Usuario:", "").strip()
 
-# --- INTERFAZ ---
-demo = gr.ChatInterface(fn=responder, title="Mi IA Personal", description="Modelo MiniGPT entrenado.")
+    # --- LIMPIEZA FINAL ---
+    # Eliminamos cualquier residuo de las etiquetas de entrenamiento
+    output = ai_txt.split("###")[0].strip()
+    
+    # Si la respuesta es nula o basura, damos un aviso
+    if not output:
+        return "Lo siento, todavía estoy aprendiendo de este dataset..."
+        
+    return output
+
+# --- INTERFAZ GRADIO ---
+demo = gr.ChatInterface(
+    fn=responder, 
+    title="Mi IA Personal (Sync Edition)", 
+    description="Entrenando en PC -> Desplegado en HF. Sincronización de respuestas activa.",
+    examples=["Hola", "¿Qué tal?", "Cuéntame algo"],
+    theme="soft"
+)
 
 if __name__ == "__main__":
-    demo.launch()
-    aunch()
+    demo.launch()