Delete app.py

app.py

@@ -1,575 +0,0 @@
-# -*- 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")