DeepseekV1

app.py

@@ -1,138 +1,87 @@
 import os
+import torch
 import gradio as gr
-import requests
-from huggingface_hub import InferenceClient
-
-"""
-For more information on `huggingface_hub` Inference API support, 
-please check the docs: 
-https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
-"""
-
-# ----------------------------------------------------------------
-# CONFIGURACIÓN DE SERPER (búsqueda web)
-# ----------------------------------------------------------------
-SERPER_API_KEY = os.getenv("SERPER_API_KEY")
-
-def do_websearch(query: str) -> str:
-    """
-    Llama a serper.dev para hacer la búsqueda en Google y devolver
-    un texto resumido de los resultados.
-    """
-    if not SERPER_API_KEY:
-        return "(SERPER_API_KEY no está configurado)"
-
-    url = "https://google.serper.dev/search"
-    headers = {
-        "X-API-KEY": SERPER_API_KEY,
-        "Content-Type": "application/json",
-    }
-    payload = {"q": query}
-
-    try:
-        resp = requests.post(url, json=payload, headers=headers, timeout=10)
-        data = resp.json()
-    except Exception as e:
-        return f"(Error al llamar a serper.dev: {e})"
-
-    # Se espera un campo 'organic' con resultados
-    if "organic" not in data:
-        return "No se encontraron resultados en serper.dev."
-
-    results = data["organic"]
-    if not results:
-        return "No hay resultados relevantes."
-
-    text = []
-    for i, item in enumerate(results, start=1):
-        title = item.get("title", "Sin título")
-        link = item.get("link", "Sin enlace")
-        text.append(f"{i}. {title}\n   {link}")
-
-    return "\n".join(text)
+from transformers import (
+    AutoTokenizer,
+    AutoModelForCausalLM,
+    TextIteratorStreamer,
+)
 
+# 1) Cargamos el tokenizer y el modelo de deepseek-ai/DeepSeek-R1-Distill-Llama-8B
+print("Cargando tokenizer...")
+tokenizer = AutoTokenizer.from_pretrained("deepseek-ai/DeepSeek-R1-Distill-Llama-8B")
 
-# ----------------------------------------------------------------
-# CONFIGURACIÓN DEL MODELO
-# ----------------------------------------------------------------
-client = InferenceClient("meta-llama/Llama-3.1-8B-Instruct")
+print("Cargando modelo (puede tardar varios minutos)...")
+model = AutoModelForCausalLM.from_pretrained(
+    "deepseek-ai/DeepSeek-R1-Distill-Llama-8B",
+    device_map="auto",          # Para usar GPU si está disponible
+    torch_dtype=torch.float16    # Usa float16 en GPU; en CPU, cambia a float32
+)
+model.eval()
 
 def respond(
     message,
     history: list[tuple[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-    use_search  # <-- Nuevo parámetro: si está "activado" el botón
+    system_message: str,
+    max_tokens: int,
+    temperature: float,
+    top_p: float,
 ):
     """
     - system_message: Texto del rol "system"
-    - history: lista de (user_msg, assistant_msg)
+    - history: Historial [(user_message, assistant_reply), ...]
     - message: Mensaje actual del usuario
-    - use_search: booleano que indica si se habilita la búsqueda en serper
+    Genera una respuesta en streaming usando transformers.TextIteratorStreamer
     """
 
-    # ----------------------------------------------------------------
-    # 1) Si el toggle está activo, hacemos búsqueda y la agregamos al prompt
-    # ----------------------------------------------------------------
-    if use_search:
-        web_info = do_websearch(message)
-        # Agregamos info al final del texto del usuario
-        message = f"{message}\nInformación de la web:\n{web_info}"
-
-    # ----------------------------------------------------------------
-    # 2) Construimos la lista de mensajes para la API de chat
-    # ----------------------------------------------------------------
-    messages = [{"role": "system", "content": system_message}]
-    for val in history:
-        if val[0]:
-            messages.append({"role": "user", "content": val[0]})
-        if val[1]:
-            messages.append({"role": "assistant", "content": val[1]})
-
-    # Añadimos el mensaje nuevo del usuario (posiblemente complementado con la info web)
-    messages.append({"role": "user", "content": message})
-
-    # ----------------------------------------------------------------
-    # 3) Llamamos a la API con streaming de tokens
-    # ----------------------------------------------------------------
-    response = ""
-    for chunk in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
+    # Construimos un prompt concatenando 'system_message', 'history' y el nuevo 'message'
+    # Esto es un ejemplo de formateo sencillo. Ajusta según tu preferencia de estilo chat.
+    prompt = f"[SYSTEM] {system_message}\n"
+    for (usr, bot) in history:
+        if usr:
+            prompt += f"[USER] {usr}\n"
+        if bot:
+            prompt += f"[ASSISTANT] {bot}\n"
+    prompt += f"[USER] {message}\n[ASSISTANT]"
+
+    # Usamos TextIteratorStreamer para obtener tokens a medida que se generan
+    streamer = TextIteratorStreamer(
+        tokenizer=tokenizer,
+        skip_special_tokens=True
+    )
+
+    # Preparamos argumentos para model.generate
+    # (similar a pipeline pero de bajo nivel)
+    inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
+    generation_kwargs = dict(
+        **inputs,
+        streamer=streamer,
+        max_new_tokens=max_tokens,
         temperature=temperature,
         top_p=top_p,
-    ):
-        token = chunk.choices[0].delta.get("content", "")
-        response += token
-        yield response
-
-
-# ----------------------------------------------------------------
-# CONFIGURACIÓN DE LA INTERFAZ
-# ----------------------------------------------------------------
-# Para usar Tailwind, podemos asignar clases en "elem_classes".
-# Ejemplo de clases genéricas (puedes cambiarlas a tu gusto):
-tailwind_toggle_classes = [
-    "inline-flex", 
-    "items-center", 
-    "bg-blue-500", 
-    "hover:bg-blue-700",
-    "text-white", 
-    "font-bold", 
-    "py-1", 
-    "px-2", 
-    "rounded", 
-    "cursor-pointer"
-]
-
-# ChatInterface, con un input Checkbox para "🌐 Búsqueda"
+        do_sample=True,           # para permitir sampling
+        # repetition_penalty=1.0,  # ajusta si lo deseas
+    )
+
+    # Lanzamos la generación en un hilo
+    generation_thread = torch.Thread(
+        target=model.generate,
+        kwargs=generation_kwargs
+    )
+    generation_thread.start()
+
+    # Leemos tokens a medida que se generan y yield
+    output_text = ""
+    for new_token in streamer:
+        output_text += new_token
+        yield output_text
+
+# Interfaz con ChatInterface
 demo = gr.ChatInterface(
     fn=respond,
     additional_inputs=[
         gr.Textbox(
+            label="Mensaje del sistema",
             value=(
                 "Eres Juan, un asistente virtual en español. "
                 "Debes responder con mucha paciencia y empatía a usuarios que "
@@ -140,37 +89,13 @@ demo = gr.ChatInterface(
                 "Provee explicaciones simples, procura entender la intención del usuario "
                 "aunque la frase esté mal escrita, y mantén siempre un tono amable."
             ),
-            label="Mensaje del sistema",
-        ),
-        gr.Slider(
-            minimum=1, 
-            maximum=2048, 
-            value=512, 
-            step=1, 
-            label="Máxima cantidad de tokens"
-        ),
-        gr.Slider(
-            minimum=0.1, 
-            maximum=4.0, 
-            value=0.7, 
-            step=0.1, 
-            label="Temperatura"
-        ),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (muestreo por núcleo)",
-        ),
-        # Un checkbox que hace de "toggle" para la búsqueda
-        gr.Checkbox(
-            value=False,         # Por defecto desactivado
-            label="🌐 Búsqueda", # Etiqueta
-            elem_classes=tailwind_toggle_classes
         ),
+        gr.Slider(1, 2048, 512, 1, label="Máxima cantidad de tokens"),
+        gr.Slider(0.1, 4.0, 0.7, 0.1, label="Temperatura"),
+        gr.Slider(0.1, 1.0, 0.95, 0.05, label="Top-p (muestreo por núcleo)"),
     ],
 )
 
 if __name__ == "__main__":
+    print("Iniciando servidor Gradio...")
     demo.launch()