Create app.py

app.py

@@ -0,0 +1,575 @@
+# -*- coding: utf-8 -*-
+"""
+MTP 1.0 API - RESPUESTAS COMPLETAS
+- Sin cortes artificiales
+- El modelo decide cuándo terminar
+- Respuestas naturales y coherentes
+- Máximo 250 tokens (suficiente para respuestas completas)
+"""
+
+import os
+import sys
+import torch
+import json
+import time
+import gc
+import re
+from fastapi import FastAPI
+from fastapi.responses import HTMLResponse
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, Field
+from huggingface_hub import snapshot_download
+import uvicorn
+import math
+import torch.nn as nn
+import torch.nn.functional as F
+import sentencepiece as spm
+
+# ======================
+# OPTIMIZACIONES
+# ======================
+if torch.cuda.is_available():
+    DEVICE = "cuda"
+    print("✅ GPU detectada")
+else:
+    DEVICE = "cpu"
+    torch.set_num_threads(min(2, os.cpu_count() or 2))
+    torch.set_num_interop_threads(1)
+    torch.set_grad_enabled(False)
+    print("⚠️ Usando CPU optimizado")
+
+MODEL_REPO = "TeszenAI/dango"
+
+# ======================
+# ARQUITECTURA MTP 1.0
+# ======================
+class RMSNorm(nn.Module):
+    __slots__ = ('weight', 'eps')
+    def __init__(self, d_model, eps=1e-6):
+        super().__init__()
+        self.weight = nn.Parameter(torch.ones(d_model))
+        self.eps = eps
+    def forward(self, x):
+        rms = torch.sqrt(x.pow(2).mean(-1, keepdim=True) + self.eps)
+        return self.weight * (x / rms)
+
+class SwiGLU(nn.Module):
+    __slots__ = ('w1', 'w2', 'w3')
+    def __init__(self, d_model, d_ff):
+        super().__init__()
+        self.w1 = nn.Linear(d_model, d_ff, bias=False)
+        self.w2 = nn.Linear(d_ff, d_model, bias=False)
+        self.w3 = nn.Linear(d_model, d_ff, bias=False)
+    def forward(self, x):
+        return self.w2(F.silu(self.w1(x)) * self.w3(x))
+
+class RotaryPositionalEmbedding(nn.Module):
+    __slots__ = ('inv_freq',)
+    def __init__(self, d_model, max_len=512):
+        super().__init__()
+        inv_freq = 1.0 / (10000 ** (torch.arange(0, d_model, 2).float() / d_model))
+        self.register_buffer('inv_freq', inv_freq)
+    def forward(self, x, seq_len=None):
+        if seq_len is None:
+            seq_len = x.shape[1]
+        t = torch.arange(seq_len, device=x.device).type_as(self.inv_freq)
+        freqs = torch.einsum('i,j->ij', t, self.inv_freq)
+        emb = torch.cat((freqs, freqs), dim=-1)
+        return torch.cos(emb), torch.sin(emb)
+
+class RotaryMultiHeadAttention(nn.Module):
+    __slots__ = ('n_heads', 'd_k', 'w_q', 'w_k', 'w_v', 'w_o', 'dropout', 'scale', 'rotary')
+    def __init__(self, d_model, n_heads, dropout=0.1):
+        super().__init__()
+        assert d_model % n_heads == 0
+        self.n_heads = n_heads
+        self.d_k = d_model // n_heads
+        self.w_q = nn.Linear(d_model, d_model, bias=False)
+        self.w_k = nn.Linear(d_model, d_model, bias=False)
+        self.w_v = nn.Linear(d_model, d_model, bias=False)
+        self.w_o = nn.Linear(d_model, d_model, bias=False)
+        self.dropout = nn.Dropout(dropout)
+        self.scale = math.sqrt(self.d_k)
+        self.rotary = RotaryPositionalEmbedding(self.d_k)
+    def forward(self, x, mask=None):
+        b, s, _ = x.shape
+        cos, sin = self.rotary(x, s)
+        Q = self.w_q(x).view(b, s, self.n_heads, self.d_k).transpose(1, 2)
+        K = self.w_k(x).view(b, s, self.n_heads, self.d_k).transpose(1, 2)
+        V = self.w_v(x).view(b, s, self.n_heads, self.d_k).transpose(1, 2)
+        Q_rot = Q * cos.unsqueeze(0).unsqueeze(0) + self._rotate_half(Q) * sin.unsqueeze(0).unsqueeze(0)
+        K_rot = K * cos.unsqueeze(0).unsqueeze(0) + self._rotate_half(K) * sin.unsqueeze(0).unsqueeze(0)
+        scores = torch.matmul(Q_rot, K_rot.transpose(-2, -1)) / self.scale
+        if mask is not None:
+            scores = scores.masked_fill(mask == 0, float('-inf'))
+        attn = self.dropout(F.softmax(scores, dim=-1))
+        out = torch.matmul(attn, V).transpose(1, 2).contiguous().view(b, s, -1)
+        return self.w_o(out)
+    def _rotate_half(self, x):
+        x1, x2 = x.chunk(2, dim=-1)
+        return torch.cat((-x2, x1), dim=-1)
+
+class TransformerBlock(nn.Module):
+    __slots__ = ('attn', 'ff', 'norm1', 'norm2', 'dropout1', 'dropout2')
+    def __init__(self, d_model, n_heads, d_ff, dropout=0.1):
+        super().__init__()
+        self.attn = RotaryMultiHeadAttention(d_model, n_heads, dropout)
+        self.ff = SwiGLU(d_model, d_ff)
+        self.norm1 = RMSNorm(d_model)
+        self.norm2 = RMSNorm(d_model)
+        self.dropout1 = nn.Dropout(dropout)
+        self.dropout2 = nn.Dropout(dropout)
+    def forward(self, x, mask=None):
+        x = x + self.dropout1(self.attn(self.norm1(x), mask))
+        x = x + self.dropout2(self.ff(self.norm2(x)))
+        return x
+
+class MTP1Model(nn.Module):
+    def __init__(self, vocab_size, d_model=512, n_heads=16, n_layers=8, d_ff=2048, dropout=0.1, max_len=512):
+        super().__init__()
+        self.vocab_size = vocab_size
+        self.d_model = d_model
+        self.max_len = max_len
+        self.embedding = nn.Embedding(vocab_size, d_model)
+        self.blocks = nn.ModuleList([TransformerBlock(d_model, n_heads, d_ff, dropout) for _ in range(n_layers)])
+        self.norm = RMSNorm(d_model)
+        self.lm_head = nn.Linear(d_model, vocab_size)
+        self.dropout = nn.Dropout(dropout)
+    def forward(self, x):
+        seq_len = x.size(1)
+        mask = torch.tril(torch.ones(seq_len, seq_len)).unsqueeze(0).unsqueeze(0).to(x.device)
+        x = self.embedding(x) * math.sqrt(self.d_model)
+        x = self.dropout(x)
+        for block in self.blocks:
+            x = block(x, mask)
+        return self.lm_head(self.norm(x))
+    
+    @torch.no_grad()
+    def generate(self, input_ids, max_new=200, temperature=0.45, top_k=30, top_p=0.88, repetition_penalty=1.2):
+        """Generación sin cortes artificiales - el modelo decide cuándo parar"""
+        generated = input_ids
+        eos_id = 3
+        last_tokens = []
+        
+        for step in range(max_new):
+            if generated.size(1) > self.max_len:
+                context = generated[:, -self.max_len:]
+            else:
+                context = generated
+            logits = self(context)
+            next_logits = logits[0, -1, :].clone() / temperature
+            
+            if repetition_penalty != 1.0:
+                for token_id in set(generated[0].tolist()):
+                    next_logits[token_id] /= repetition_penalty
+            
+            if top_k > 0:
+                indices = next_logits < torch.topk(next_logits, top_k)[0][..., -1, None]
+                next_logits[indices] = float('-inf')
+            if top_p < 1.0:
+                sorted_logits, sorted_indices = torch.sort(next_logits, descending=True)
+                cum_probs = torch.cumsum(F.softmax(sorted_logits, dim=-1), dim=-1)
+                remove = cum_probs > top_p
+                remove[..., 1:] = remove[..., :-1].clone()
+                remove[..., 0] = 0
+                indices = sorted_indices[remove]
+                next_logits[indices] = float('-inf')
+            
+            probs = F.softmax(next_logits, dim=-1)
+            next_token = torch.multinomial(probs, 1).item()
+            
+            last_tokens.append(next_token)
+            if len(last_tokens) > 6 and len(set(last_tokens)) <= 2:
+                break
+            
+            if next_token == eos_id or next_token == 0:
+                break
+            
+            generated = torch.cat([generated, torch.tensor([[next_token]], device=generated.device)], dim=1)
+            
+            # Parada natural: si encontramos un punto y llevamos suficientes tokens
+            if step > 30:
+                # Decodificar últimos tokens para ver si hay punto final
+                recent = generated[0][-5:].tolist()
+                # El token 3 es EOS, 4 podría ser punto dependiendo del tokenizer
+                if 3 in recent:
+                    break
+        
+        return generated
+
+# ======================
+# LIMPIEZA MÍNIMA (SOLO LO ESENCIAL)
+# ======================
+def clean_response(response: str) -> str:
+    """Solo elimina repeticiones y espacios, NO corta el texto"""
+    if not response:
+        return ""
+    
+    # Eliminar repeticiones excesivas de palabras
+    words = response.split()
+    cleaned = []
+    last = ""
+    for w in words:
+        if w.lower() != last.lower():
+            cleaned.append(w)
+            last = w
+    response = " ".join(cleaned)
+    
+    # Limpiar espacios múltiples
+    response = re.sub(r'\s+', ' ', response).strip()
+    
+    # Capitalizar primera letra
+    if response and response[0].islower():
+        response = response[0].upper() + response[1:]
+    
+    # NO cortamos el texto - la respuesta queda completa
+    return response
+
+# ======================
+# CARGA DEL MODELO
+# ======================
+print(f"📦 Descargando MTP 1.0 desde {MODEL_REPO}...")
+repo_path = snapshot_download(repo_id=MODEL_REPO, repo_type="model", local_dir="mtp_repo")
+
+config_path = os.path.join(repo_path, "config.json")
+with open(config_path, "r") as f:
+    config = json.load(f)
+
+tokenizer_path = os.path.join(repo_path, "mtp_tokenizer.model")
+sp = spm.SentencePieceProcessor()
+sp.load(tokenizer_path)
+config["vocab_size"] = sp.get_piece_size()
+
+print(f"🧠 Inicializando MTP 1.0...")
+print(f"   → Vocabulario: {config['vocab_size']} tokens")
+print(f"   → Dimensiones: {config.get('d_model', 512)}")
+print(f"   → Capas: {config.get('n_layers', 8)}")
+
+model = MTP1Model(**config)
+model.to(DEVICE)
+model.eval()
+
+model_path = os.path.join(repo_path, "mtp_model.pt")
+if os.path.exists(model_path):
+    state_dict = torch.load(model_path, map_location=DEVICE)
+    model.load_state_dict(state_dict, strict=False)
+    print("✅ Pesos cargados")
+
+param_count = sum(p.numel() for p in model.parameters())
+print(f"✅ MTP 1.0 listo: {param_count:,} parámetros ({param_count/1e6:.2f}M)")
+
+# ======================
+# API
+# ======================
+app = FastAPI(title="MTP 1.0 API", version="1.0")
+app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"])
+
+class PromptRequest(BaseModel):
+    text: str = Field(..., max_length=2000)
+
+def build_prompt(user_input: str) -> str:
+    return f"### Instrucción:\n{user_input}\n\n### Respuesta:\n"
+
+ACTIVE_REQUESTS = 0
+
+@app.post("/generate")
+async def generate(req: PromptRequest):
+    global ACTIVE_REQUESTS
+    ACTIVE_REQUESTS += 1
+    
+    user_input = req.text.strip()
+    if not user_input:
+        ACTIVE_REQUESTS -= 1
+        return {"reply": ""}
+    
+    tokens = sp.encode(build_prompt(user_input))[:400]
+    input_ids = torch.tensor([tokens], device=DEVICE)
+    
+    try:
+        start = time.time()
+        output_ids = model.generate(
+            input_ids, 
+            max_new=200, 
+            temperature=0.45, 
+            top_k=30, 
+            top_p=0.88, 
+            repetition_penalty=1.2
+        )
+        elapsed = time.time() - start
+        
+        gen_tokens = output_ids[0, len(tokens):].tolist()
+        safe_tokens = [t for t in gen_tokens if 0 <= t < config["vocab_size"] and t != 0]
+        
+        response = sp.decode(safe_tokens).strip() if safe_tokens else ""
+        
+        # Limpiar formato
+        for m in ["### Respuesta:", "Respuesta:", "[/INST]", "Asistente:"]:
+            if m in response:
+                response = response.split(m)[-1].strip()
+                break
+        
+        response = clean_response(response)
+        
+        if len(response) < 3:
+            response = "Lo siento, no pude generar una respuesta clara."
+
+        return {
+            "reply": response, 
+            "time": round(elapsed, 2), 
+            "tokens": len(safe_tokens),
+            "characters": len(response),
+            "model": "MTP-1.0"
+        }
+    
+    except Exception as e:
+        print(f"Error: {e}")
+        return {"reply": "Lo siento, ocurrió un error."}
+    
+    finally:
+        ACTIVE_REQUESTS -= 1
+        if DEVICE == "cuda":
+            torch.cuda.empty_cache()
+        gc.collect()
+
+@app.get("/health")
+def health():
+    return {"status": "ok", "model": "MTP-1.0", "device": DEVICE}
+
+@app.get("/info")
+def info():
+    return {
+        "model": "MTP-1.0",
+        "version": "1.0",
+        "parameters": param_count,
+        "parameters_millions": round(param_count / 1e6, 2),
+        "device": DEVICE,
+        "d_model": config.get('d_model', 512),
+        "n_layers": config.get('n_layers', 8),
+        "n_heads": config.get('n_heads', 16)
+    }
+
+# ======================
+# INTERFAZ WEB
+# ======================
+@app.get("/", response_class=HTMLResponse)
+def chat_ui():
+    return """
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>MTP 1.0 - Asistente IA</title>
+    <style>
+        * { margin: 0; padding: 0; box-sizing: border-box; }
+        body {
+            background: linear-gradient(135deg, #0a0a0a 0%, #1a1a2e 100%);
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            height: 100vh;
+            display: flex;
+            flex-direction: column;
+        }
+        .header {
+            padding: 12px 16px;
+            background: rgba(0,0,0,0.5);
+            border-bottom: 1px solid rgba(255,255,255,0.1);
+        }
+        .header h1 { color: white; font-size: 1rem; }
+        .header p { color: #888; font-size: 0.65rem; margin-top: 2px; }
+        .messages {
+            flex: 1;
+            overflow-y: auto;
+            padding: 16px;
+            display: flex;
+            flex-direction: column;
+            gap: 10px;
+        }
+        .message {
+            max-width: 85%;
+            padding: 8px 14px;
+            border-radius: 16px;
+            font-size: 0.85rem;
+            line-height: 1.4;
+            animation: fadeIn 0.2s ease;
+            word-wrap: break-word;
+        }
+        @keyframes fadeIn {
+            from { opacity: 0; transform: translateY(5px); }
+            to { opacity: 1; transform: translateY(0); }
+        }
+        .user {
+            background: linear-gradient(135deg, #4a9eff, #3a7ecc);
+            color: white;
+            align-self: flex-end;
+            border-radius: 16px 4px 16px 16px;
+        }
+        .bot {
+            background: rgba(30, 31, 40, 0.95);
+            color: #e0e0e0;
+            align-self: flex-start;
+            border-radius: 4px 16px 16px 16px;
+            border: 1px solid rgba(255,255,255,0.05);
+        }
+        .input-area {
+            padding: 12px 16px;
+            background: rgba(0,0,0,0.5);
+            border-top: 1px solid rgba(255,255,255,0.1);
+            display: flex;
+            gap: 10px;
+        }
+        input {
+            flex: 1;
+            padding: 10px 14px;
+            background: rgba(255,255,255,0.1);
+            border: 1px solid rgba(255,255,255,0.2);
+            border-radius: 24px;
+            color: white;
+            font-size: 0.85rem;
+            outline: none;
+        }
+        input:focus { border-color: #4a9eff; }
+        input::placeholder { color: #666; }
+        button {
+            padding: 10px 20px;
+            background: linear-gradient(135deg, #4a9eff, #3a7ecc);
+            border: none;
+            border-radius: 24px;
+            color: white;
+            font-weight: 500;
+            cursor: pointer;
+            font-size: 0.85rem;
+        }
+        button:hover { opacity: 0.9; }
+        button:disabled { opacity: 0.5; cursor: not-allowed; }
+        .typing {
+            background: rgba(30, 31, 40, 0.95);
+            padding: 8px 14px;
+            border-radius: 16px;
+            align-self: flex-start;
+            display: flex;
+            gap: 4px;
+        }
+        .typing span {
+            width: 6px;
+            height: 6px;
+            background: #888;
+            border-radius: 50%;
+            animation: bounce 1.4s infinite;
+        }
+        @keyframes bounce {
+            0%, 80%, 100% { transform: scale(0); }
+            40% { transform: scale(1); }
+        }
+        .badge {
+            position: fixed;
+            bottom: 5px;
+            right: 5px;
+            font-size: 0.55rem;
+            color: #555;
+            background: rgba(0,0,0,0.5);
+            padding: 2px 6px;
+            border-radius: 10px;
+        }
+        @media (max-width: 600px) {
+            .message { max-width: 95%; }
+        }
+    </style>
+</head>
+<body>
+    <div class="header">
+        <h1>🤖 MTP 1.0 - Asistente IA</h1>
+        <p>✨ Respuestas completas y naturales | Sin cortes | Inteligente</p>
+    </div>
+    <div class="messages" id="messages">
+        <div class="message bot">✨ Hola, soy MTP 1.0. Doy respuestas completas y naturales, sin cortes artificiales. ¿En qué puedo ayudarte?</div>
+    </div>
+    <div class="input-area">
+        <input type="text" id="input" placeholder="Escribe tu pregunta..." autocomplete="off">
+        <button id="send">Enviar</button>
+    </div>
+    <div class="badge">⚡ MTP 1.0 | 🌡️ 0.45 | Respuestas completas</div>
+    <script>
+        const messages = document.getElementById('messages');
+        const input = document.getElementById('input');
+        const sendBtn = document.getElementById('send');
+        let loading = false;
+        
+        function addMessage(text, isUser, time = null, chars = null) {
+            const div = document.createElement('div');
+            div.className = `message ${isUser ? 'user' : 'bot'}`;
+            let info = '';
+            if (time) info += `⚡ ${time}s`;
+            if (chars) info += `${info ? ' | ' : ''}📝 ${chars} chars`;
+            div.innerHTML = `<div>${escapeHtml(text)}</div>${info ? `<div style="font-size:0.6rem;color:#666;margin-top:4px;">${info}</div>` : ''}`;
+            messages.appendChild(div);
+            messages.scrollTop = messages.scrollHeight;
+        }
+        
+        function escapeHtml(text) {
+            const div = document.createElement('div');
+            div.textContent = text;
+            return div.innerHTML;
+        }
+        
+        function showTyping() {
+            const div = document.createElement('div');
+            div.className = 'typing';
+            div.id = 'typing';
+            div.innerHTML = '<span></span><span></span><span></span>';
+            messages.appendChild(div);
+            messages.scrollTop = messages.scrollHeight;
+        }
+        
+        function hideTyping() {
+            const el = document.getElementById('typing');
+            if (el) el.remove();
+        }
+        
+        async function sendMessage() {
+            const text = input.value.trim();
+            if (!text || loading) return;
+            
+            input.value = '';
+            addMessage(text, true);
+            loading = true;
+            sendBtn.disabled = true;
+            showTyping();
+            
+            try {
+                const response = await fetch('/generate', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ text: text })
+                });
+                const data = await response.json();
+                hideTyping();
+                addMessage(data.reply, false, data.time, data.characters);
+            } catch (error) {
+                hideTyping();
+                addMessage('⚠️ Error de conexión. Intenta de nuevo.', false);
+            } finally {
+                loading = false;
+                sendBtn.disabled = false;
+                input.focus();
+            }
+        }
+        
+        input.addEventListener('keypress', (e) => { if (e.key === 'Enter') sendMessage(); });
+        sendBtn.addEventListener('click', sendMessage);
+        input.focus();
+    </script>
+</body>
+</html>
+"""
+
+if __name__ == "__main__":
+    port = int(os.environ.get("PORT", 7860))
+    print("\n" + "=" * 60)
+    print(f"🚀 MTP 1.0 en http://0.0.0.0:{port}")
+    print(f"📊 Parámetros: {param_count:,} ({param_count/1e6:.2f}M)")
+    print(f"🌡️ Temperatura: 0.45 | 🔁 Repetition penalty: 1.2")
+    print(f"💡 Respuestas completas - El modelo decide cuándo terminar")
+    print(f"💻 Dispositivo: {DEVICE.upper()}")
+    print("=" * 60)
+    
+    uvicorn.run(app, host="0.0.0.0", port=port, log_level="warning")