Update app.py

app.py

@@ -35,84 +35,147 @@ torch.set_grad_enabled(False)
 MODEL_REPO = "TeszenAI/MTP-3.1.1"
 
 # ======================
-# FUNCIONES DE LIMPIEZA Y CONTROL DE CALIDAD
+# FUNCIONES DE LIMPIEZA Y CONTROL DE CALIDAD (MEJORADAS)
 # ======================
 
-def truncate_greeting_response(text: str) -> str:
-    """
-    Para respuestas de saludo, trunca SOLO en el primer PUNTO (.)
-    No usa signos de exclamación o interrogación.
-    """
-    if not text:
+def is_greeting(user_input: str) -> bool:
+    """Detecta si el mensaje es un saludo simple"""
+    greetings = ["hola", "hola!", "hola.", "buenas", "saludos", "hola?", "buen día", "buenas tardes", "buenas noches"]
+    return user_input.lower().strip() in greetings
+
+def truncate_response(text: str, max_length: int = 300) -> str:
+    """Trunca respuesta de forma limpia en oraciones completas"""
+    if not text or len(text) <= max_length:
         return text
     
-    # Buscar el primer PUNTO (.)
-    end_match = re.search(r'\.', text)
+    # Intentar truncar en el último punto dentro del límite
+    last_period = text[:max_length].rfind('.')
+    if last_period > max_length // 2:
+        return text[:last_period + 1].strip()
     
-    if end_match:
-        # Cortar justo después del punto
-        end_pos = end_match.end()
-        truncated = text[:end_pos].strip()
-        return truncated
+    # Si no hay punto, truncar en espacio
+    last_space = text[:max_length].rfind(' ')
+    if last_space > max_length // 2:
+        return text[:last_space].strip() + "..."
     
-    # Si no hay punto, devolver solo primeras 80 caracteres
-    if len(text) > 80:
-        return text[:80] + "..."
-    return text
+    return text[:max_length].strip() + "..."
 
 def clean_response(text: str, user_input: str = "") -> str:
-    """Limpia la respuesta del modelo"""
+    """
+    Limpia la respuesta del modelo de forma más agresiva
+    Elimina alucinaciones, repeticiones y caracteres raros
+    """
     if not text:
         return ""
     
-    # Eliminar repeticiones excesivas
+    # Eliminar repeticiones excesivas de palabras (más agresivo)
     words = text.split()
     cleaned_words = []
     last_word = ""
     repeat_count = 0
+    last_two_words = []
     
     for word in words:
+        # Detectar repeticiones inmediatas
         if word == last_word:
             repeat_count += 1
-            if repeat_count > 2:
+            if repeat_count > 1:  # Más estricto: solo permitir 1 repetición
                 continue
         else:
             last_word = word
             repeat_count = 0
+        
+        # Detectar patrones repetitivos de 2-3 palabras
+        last_two_words.append(word)
+        if len(last_two_words) > 3:
+            last_two_words.pop(0)
+        
+        if len(last_two_words) >= 2:
+            # Si las últimas 2-3 palabras ya aparecieron antes, omitir
+            if len(cleaned_words) > len(last_two_words) * 2:
+                pattern = ' '.join(last_two_words)
+                text_so_far = ' '.join(cleaned_words[-len(last_two_words)*2:])
+                if pattern in text_so_far:
+                    continue
+        
         cleaned_words.append(word)
     
     text = " ".join(cleaned_words)
     
-    # Eliminar caracteres raros
-    text = re.sub(r'(.)\1{4,}', r'\1\1', text)
+    # Eliminar caracteres raros y patrones no deseados
+    text = re.sub(r'(.)\1{5,}', r'\1\1', text)  # Caracteres repetidos más de 5 veces
+    text = re.sub(r'[^\w\s\.\,\!\?\-\'\¡\¿áéíóúñÑ]', '', text)  # Caracteres especiales no deseados
+    
+    # Eliminar URLs y menciones extrañas
+    text = re.sub(r'https?://\S+|www\.\S+', '[enlace]', text)
+    text = re.sub(r'@\w+', '', text)
+    
+    # Eliminar secuencias numéricas largas
+    text = re.sub(r'\b\d{10,}\b', '', text)
+    
+    # Para saludos, respuesta corta y precisa
+    if is_greeting(user_input):
+        # Respuesta de saludo estándar sin inventar
+        return "¡Hola! ¿En qué puedo ayudarte?"
+    
+    # Si la respuesta es muy larga, truncar
+    if len(text) > 500:
+        text = truncate_response(text, 400)
+    
+    # Eliminar frases de "auto-referencia" comunes que indican alucinación
+    hallucination_patterns = [
+        r'(?i)como modelo de lenguaje (?:IA|inteligencia artificial|AI)',
+        r'(?i)soy una (?:IA|inteligencia artificial)',
+        r'(?i)no tengo (?:emociones|sentimientos|conciencia)',
+        r'(?i)disculpa las molestias',
+        r'(?i)lo siento(?:,)? (?:no puedo|no sé|no entiendo)',
+        r'(?i)como (?:asistente|IA) virtual',
+        r'(?i)basado en mi (?:entrenamiento|conocimiento)',
+        r'(?i)no (?:tengo|poseo) (?:acceso|información)',
+    ]
     
-    # Detectar si es un saludo
-    is_greeting = user_input.lower().strip() in ["hola", "hola!", "hola.", "buenas", "saludos", "hola?"]
+    for pattern in hallucination_patterns:
+        text = re.sub(pattern, '', text, flags=re.IGNORECASE)
     
-    if is_greeting and text:
-        # Para saludos, truncar SOLO en el primer PUNTO (.)
-        punct_match = re.search(r'\.', text)
-        if punct_match:
-            text = text[:punct_match.end()].strip()
+    # Si después de limpiar la respuesta es muy corta o vacía
+    if len(text.strip()) < 10:
+        # Respuesta por defecto según el contexto
+        if any(q in user_input.lower() for q in ['cómo estás', 'como estas', 'que tal']):
+            return "Estoy bien, gracias por preguntar. ¿En qué puedo ayudarte?"
+        elif any(q in user_input.lower() for q in ['quién eres', 'quien eres', 'que eres']):
+            return "Soy un asistente de IA. ¿En qué puedo ayudarte?"
         else:
-            # Si no hay punto, tomar solo la primera oración o 60 caracteres
-            first_sentence = text.split('.')[0].strip()
-            if len(first_sentence) > 5:
-                text = first_sentence
-            elif len(text) > 60:
-                text = text[:60]
-    
-    # Si la respuesta es muy corta o vacía
-    if len(text.strip()) < 5:
-        if is_greeting:
-            return "¡Hola! ¿En qué puedo ayudarte?"
-        return "Lo siento, no pude generar una respuesta clara. ¿Podrías reformular tu pregunta?"
-    
-    # Eliminar espacios múltiples
+            return "No pude procesar tu solicitud correctamente. ¿Podrías reformular tu pregunta?"
+    
+    # Eliminar espacios múltiples y limpiar
     text = re.sub(r'\s+', ' ', text).strip()
     
+    # Asegurar que termine con puntuación
+    if text and text[-1] not in '.!?':
+        text += '.'
+    
     return text
 
+def format_prompt(user_input: str) -> str:
+    """
+    Formato de prompt más estructurado para reducir alucinaciones
+    """
+    # Detectar tipo de pregunta para mejor contexto
+    user_lower = user_input.lower()
+    
+    if is_greeting(user_input):
+        return "### Instrucción:\nSaluda cortésmente.\n\n### Respuesta:\n¡Hola! ¿En qué puedo ayudarte?"
+    
+    # Prompt estructurado para respuestas más precisas
+    prompt = f"""### Instrucción:
+Responde la siguiente pregunta de forma CONCISA y DIRECTA. No inventes información. Si no sabes la respuesta, dilo claramente.
+
+Pregunta: {user_input}
+
+### Respuesta:"""
+    
+    return prompt
+
 # ======================
 # DEFINIR ARQUITECTURA DEL MODELO (MTP)
 # ======================
@@ -224,8 +287,12 @@ class MTPModel(nn.Module):
         logits = self.lm_head(x)
         return logits
     
-    def generate(self, input_ids, max_new_tokens=150, temperature=0.8, top_k=50, top_p=0.9, repetition_penalty=1.1):
-        """Genera texto token por token"""
+    def generate(self, input_ids, max_new_tokens=150, temperature=0.5, top_k=30, top_p=0.85, repetition_penalty=1.2):
+        """
+        Genera texto con parámetros más conservadores para respuestas precisas
+        temperature más baja = menos creatividad
+        repetition_penalty más alto = menos repeticiones
+        """
         generated = input_ids
         
         for step in range(max_new_tokens):
@@ -233,14 +300,17 @@ class MTPModel(nn.Module):
                 logits = self(generated)
                 next_logits = logits[0, -1, :] / temperature
             
+            # Penalización por repetición más agresiva
             if repetition_penalty != 1.0:
                 for token_id in set(generated[0].tolist()):
                     next_logits[token_id] /= repetition_penalty
             
+            # Top-k más restrictivo
             if top_k > 0:
                 indices_to_remove = next_logits < torch.topk(next_logits, top_k)[0][..., -1, None]
                 next_logits[indices_to_remove] = float('-inf')
             
+            # Top-p más restrictivo
             if top_p < 1.0:
                 sorted_logits, sorted_indices = torch.sort(next_logits, descending=True)
                 cumulative_probs = torch.cumsum(F.softmax(sorted_logits, dim=-1), dim=-1)
@@ -328,8 +398,8 @@ print(f"✅ Modelo cargado: {param_count:,} parámetros ({param_count/1e6:.1f}M)
 # ======================
 app = FastAPI(
     title="MTP API",
-    description="API para modelo de lenguaje MTP",
-    version="1.0"
+    description="API para modelo de lenguaje MTP - Respuestas precisas y concisas",
+    version="1.1"
 )
 
 app.add_middleware(
@@ -341,15 +411,11 @@ app.add_middleware(
 
 class PromptRequest(BaseModel):
     text: str = Field(..., max_length=2000, description="Texto de entrada")
-    max_tokens: int = Field(default=100, ge=10, le=200, description="Tokens máximos a generar")
-    temperature: float = Field(default=0.7, ge=0.1, le=2.0, description="Temperatura de muestreo")
-    top_k: int = Field(default=50, ge=1, le=100, description="Top-k sampling")
-    top_p: float = Field(default=0.9, ge=0.1, le=1.0, description="Top-p (nucleus) sampling")
-    repetition_penalty: float = Field(default=1.1, ge=1.0, le=2.0, description="Penalización por repetición")
-
-def build_prompt(user_input: str) -> str:
-    """Construye el prompt en el formato del modelo"""
-    return f"### Instrucción:\n{user_input}\n\n### Respuesta:\n"
+    max_tokens: int = Field(default=80, ge=10, le=150, description="Tokens máximos a generar")
+    temperature: float = Field(default=0.5, ge=0.1, le=1.5, description="Temperatura de muestreo (menor = más preciso)")
+    top_k: int = Field(default=30, ge=1, le=80, description="Top-k sampling")
+    top_p: float = Field(default=0.85, ge=0.1, le=1.0, description="Top-p (nucleus) sampling")
+    repetition_penalty: float = Field(default=1.2, ge=1.0, le=2.0, description="Penalización por repetición")
 
 # ======================
 # GESTIÓN DE CARGA
@@ -380,7 +446,7 @@ tokenizer_wrapper = MTPTokenizer(sp)
 
 @app.post("/generate")
 async def generate(req: PromptRequest):
-    """Endpoint principal de generación de texto"""
+    """Endpoint principal de generación de texto - Versión mejorada para respuestas precisas"""
     global ACTIVE_REQUESTS
     ACTIVE_REQUESTS += 1
     
@@ -389,15 +455,41 @@ async def generate(req: PromptRequest):
         ACTIVE_REQUESTS -= 1
         return {"reply": "", "tokens_generated": 0}
     
-    # Detectar si es un saludo
-    is_greeting = user_input.lower().strip() in ["hola", "hola!", "hola.", "buenas", "saludos", "hola?"]
+    # Detectar tipo de mensaje
+    is_greeting_msg = is_greeting(user_input)
     
-    # Si es saludo, usar menos tokens
-    max_tokens = 30 if is_greeting else req.max_tokens
-
-    full_prompt = build_prompt(user_input)
+    # Para saludos, respuesta directa sin generar
+    if is_greeting_msg:
+        ACTIVE_REQUESTS -= 1
+        return {
+            "reply": "¡Hola! ¿En qué puedo ayudarte?",
+            "tokens_generated": 0,
+            "model": "MTP",
+            "mode": "direct"
+        }
+    
+    # Para preguntas muy cortas o confusas, pedir aclaración
+    if len(user_input) < 5 and not is_greeting_msg:
+        ACTIVE_REQUESTS -= 1
+        return {
+            "reply": "¿Podrías ser más específico? No entendí tu pregunta.",
+            "tokens_generated": 0,
+            "model": "MTP",
+            "mode": "clarify"
+        }
+    
+    # Construir prompt estructurado
+    full_prompt = format_prompt(user_input)
     tokens = tokenizer_wrapper.encode(full_prompt)
+    
+    # Limitar longitud de entrada para evitar contextos muy largos
+    if len(tokens) > 256:
+        tokens = tokens[:256]
+    
     input_ids = torch.tensor([tokens], device=DEVICE)
+    
+    # Ajustar max_tokens según la pregunta
+    max_tokens = min(req.max_tokens, 100)  # Limitar a 100 tokens máximo para respuestas concisas
 
     try:
         with torch.no_grad():
@@ -420,30 +512,28 @@ async def generate(req: PromptRequest):
         else:
             response = ""
         
-        # Limpiar respuesta
+        # Limpiar respuesta (elimina alucinaciones y repeticiones)
         response = clean_response(response, user_input)
         
+        # Verificar si la respuesta es demasiado larga o no tiene sentido
+        if len(response) > 400:
+            response = truncate_response(response, 350)
+        
         # Si la respuesta sigue vacía o es muy corta, usar respuesta por defecto
-        if len(response) < 3:
-            if is_greeting:
-                response = "¡Hola! ¿En qué puedo ayudarte?"
-            else:
-                response = "Lo siento, no pude generar una respuesta. ¿Podrías reformular tu pregunta?"
+        if len(response) < 10:
+            response = "Lo siento, no pude generar una respuesta precisa. ¿Podrías reformular tu pregunta?"
 
         return {
             "reply": response,
             "tokens_generated": len(safe_tokens),
-            "model": "MTP"
+            "model": "MTP",
+            "mode": "generated"
         }
     
     except Exception as e:
         print(f"❌ Error durante generación: {e}")
-        if is_greeting:
-            fallback = "¡Hola! ¿En qué puedo ayudarte?"
-        else:
-            fallback = "Lo siento, ocurrió un error al procesar tu solicitud."
         return {
-            "reply": fallback,
+            "reply": "Ocurrió un error al procesar tu solicitud. Por favor, intenta de nuevo.",
             "error": str(e)
         }
     
@@ -463,21 +553,23 @@ def health_check():
         "model": "MTP",
         "device": DEVICE,
         "active_requests": ACTIVE_REQUESTS,
-        "vocab_size": VOCAB_SIZE
+        "vocab_size": VOCAB_SIZE,
+        "mode": "precise"
     }
 
 @app.get("/info")
 def model_info():
     return {
         "model_name": "MTP",
-        "version": "1.0",
+        "version": "1.1",
         "architecture": config,
         "parameters": sum(p.numel() for p in model.parameters()),
-        "device": DEVICE
+        "device": DEVICE,
+        "description": "Modelo optimizado para respuestas precisas y concisas"
     }
 
 # ======================
-# INTERFAZ WEB
+# INTERFAZ WEB MEJORADA
 # ======================
 @app.get("/", response_class=HTMLResponse)
 def chat_ui():
@@ -487,7 +579,7 @@ def chat_ui():
 <head>
 <meta charset="UTF-8">
 <meta name="viewport" content="width=device-width, initial-scale=1.0">
-<title>MTP - Asistente IA</title>
+<title>MTP - Asistente IA Preciso</title>
 <style>
 * { margin: 0; padding: 0; box-sizing: border-box; }
 body {
@@ -507,6 +599,11 @@ body {
     font-size: 1.2rem;
     font-weight: 500;
 }
+.chat-header p {
+    color: #888;
+    font-size: 0.75rem;
+    margin-top: 4px;
+}
 .chat-messages {
     flex: 1;
     overflow-y: auto;
@@ -597,15 +694,37 @@ body {
     0%, 80%, 100% { transform: scale(0); }
     40% { transform: scale(1); }
 }
+.suggestion-buttons {
+    display: flex;
+    gap: 8px;
+    margin-top: 10px;
+    flex-wrap: wrap;
+    justify-content: center;
+}
+.suggestion {
+    background: #2a2b2e;
+    border: none;
+    border-radius: 20px;
+    padding: 6px 14px;
+    color: #aaa;
+    font-size: 0.8rem;
+    cursor: pointer;
+    transition: all 0.2s;
+}
+.suggestion:hover {
+    background: #3a3b3e;
+    color: white;
+}
 </style>
 </head>
 <body>
 <div class="chat-header">
     <h1>🤖 MTP - Asistente IA</h1>
+    <p>Respuestas precisas y concisas | Modo conservador</p>
 </div>
 <div class="chat-messages" id="chatMessages">
     <div class="message bot">
-        <div class="message-content">¡Hola! Soy MTP, tu asistente de IA. ¿En qué puedo ayudarte hoy?</div>
+        <div class="message-content">¡Hola! Soy MTP, tu asistente de IA. Haré lo posible por darte respuestas precisas y concisas. ¿En qué puedo ayudarte?</div>
     </div>
 </div>
 <div class="chat-input-container">
@@ -613,6 +732,12 @@ body {
         <input type="text" id="messageInput" placeholder="Escribe tu mensaje..." autocomplete="off">
         <button id="sendBtn">Enviar</button>
     </div>
+    <div class="suggestion-buttons">
+        <button class="suggestion" data-text="¿Qué es la inteligencia artificial?">🤖 ¿Qué es la IA?</button>
+        <button class="suggestion" data-text="¿Cómo estás?">😊 ¿Cómo estás?</button>
+        <button class="suggestion" data-text="¿Quién eres?">👋 ¿Quién eres?</button>
+        <button class="suggestion" data-text="Hola">👋 Hola</button>
+    </div>
 </div>
 <script>
 const chatMessages = document.getElementById('chatMessages');
@@ -623,12 +748,18 @@ let isLoading = false;
 function addMessage(text, isUser) {
     const div = document.createElement('div');
     div.className = `message ${isUser ? 'user' : 'bot'}`;
-    div.innerHTML = `<div class="message-content">${text}</div>`;
+    div.innerHTML = `<div class="message-content">${escapeHtml(text)}</div>`;
     chatMessages.appendChild(div);
     chatMessages.scrollTop = chatMessages.scrollHeight;
     return div;
 }
 
+function escapeHtml(text) {
+    const div = document.createElement('div');
+    div.textContent = text;
+    return div.innerHTML;
+}
+
 function addTypingIndicator() {
     const div = document.createElement('div');
     div.className = 'message bot';
@@ -643,12 +774,12 @@ function removeTypingIndicator() {
     if (indicator) indicator.remove();
 }
 
-async function sendMessage() {
-    const text = messageInput.value.trim();
-    if (!text || isLoading) return;
+async function sendMessage(text = null) {
+    const messageText = text || messageInput.value.trim();
+    if (!messageText || isLoading) return;
     
-    messageInput.value = '';
-    addMessage(text, true);
+    if (!text) messageInput.value = '';
+    addMessage(messageText, true);
     isLoading = true;
     sendBtn.disabled = true;
     addTypingIndicator();
@@ -657,14 +788,14 @@ async function sendMessage() {
         const response = await fetch('/generate', {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ text: text })
+            body: JSON.stringify({ text: messageText })
         });
         const data = await response.json();
         removeTypingIndicator();
         addMessage(data.reply, false);
     } catch (error) {
         removeTypingIndicator();
-        addMessage('Error de conexión. Intenta de nuevo.', false);
+        addMessage('Error de conexión. Por favor, intenta de nuevo.', false);
     } finally {
         isLoading = false;
         sendBtn.disabled = false;
@@ -675,7 +806,15 @@ async function sendMessage() {
 messageInput.addEventListener('keypress', (e) => {
     if (e.key === 'Enter') sendMessage();
 });
-sendBtn.addEventListener('click', sendMessage);
+sendBtn.addEventListener('click', () => sendMessage());
+
+// Sugerencias
+document.querySelectorAll('.suggestion').forEach(btn => {
+    btn.addEventListener('click', () => {
+        sendMessage(btn.dataset.text);
+    });
+});
+
 messageInput.focus();
 </script>
 </body>
@@ -687,6 +826,11 @@ if __name__ == "__main__":
     print(f"\n🚀 Iniciando servidor MTP en puerto {port}...")
     print(f"🌐 Interfaz web: http://0.0.0.0:{port}")
     print(f"📡 API docs: http://0.0.0.0:{port}/docs")
+    print(f"\n⚙️ Configuración para respuestas PRECISAS:")
+    print(f"   • Temperature: 0.5 (menos creatividad)")
+    print(f"   • Top-k: 30 (muestreo más restrictivo)")
+    print(f"   • Top-p: 0.85")
+    print(f"   • Repetition penalty: 1.2 (reduce repeticiones)")
     
     uvicorn.run(
         app,