| |
| """ |
| 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 |
|
|
| |
| |
| |
| 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" |
|
|
| |
| |
| |
| 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) |
| |
| |
| if step > 30: |
| |
| recent = generated[0][-5:].tolist() |
| |
| if 3 in recent: |
| break |
| |
| return generated |
|
|
| |
| |
| |
| def clean_response(response: str) -> str: |
| """Solo elimina repeticiones y espacios, NO corta el texto""" |
| if not response: |
| return "" |
| |
| |
| words = response.split() |
| cleaned = [] |
| last = "" |
| for w in words: |
| if w.lower() != last.lower(): |
| cleaned.append(w) |
| last = w |
| response = " ".join(cleaned) |
| |
| |
| response = re.sub(r'\s+', ' ', response).strip() |
| |
| |
| if response and response[0].islower(): |
| response = response[0].upper() + response[1:] |
| |
| |
| return response |
|
|
| |
| |
| |
| 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)") |
|
|
| |
| |
| |
| 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 "" |
| |
| |
| 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) |
| } |
|
|
| |
| |
| |
| @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") |
