Update app.py

app.py

@@ -14,10 +14,7 @@ import psutil
 import os
 import gc
 import logging
-from PIL import Image
-import uuid
 from tqdm import tqdm
-from transformers import eBart
 
 logging.basicConfig(level=logging.INFO)
 
@@ -31,51 +28,34 @@ if torch.cuda.is_available():
 else:
     device = torch.device("cpu")
 
-print("Dispositivo:", device)
-
 modelos = {
     "gpt2-medium": VLLM(model="gpt2-medium"),
-    "qwen2.5-0.5b": VLLM(model="Qwen/Qwen2.5-0.5B-Instruct"),
-    "llamaxd": VLLM(model="Hjgugugjhuhjggg/llama-3.2-1B-spinquant-hf")
+    "qwen2.5-0.5b": VLLM(model="qwen2.5-0.5b"),
+    "t5-base": VLLM(model="t5-base"),
+    "bert-base-uncased": VLLM(model="bert-base-uncased"),
+    "xlnet-base-uncased": VLLM(model="xlnet-base-uncased"),
+    "distilbert-base-uncased": VLLM(model="distilbert-base-uncased"),
+    "albert-base-v2": VLLM(model="albert-base-v2"),
+    "roberta-base": VLLM(model="roberta-base"),
 }
 
-print("Cargando modelos...")
 for nombre, modelo in tqdm(modelos.items()):
     modelos[nombre] = modelo(to=device)
-    print(f"Modelo {nombre} cargado")
 
 caches = {
     nombre: GPTCache(modelo, max_size=1000) for nombre, modelo in modelos.items()
 }
 
-print("Creando instancias de caché...")
-for nombre, caché in tqdm(caches.items()):
-    print(f"Caché para modelo {nombre} creada")
-
 cadenas = {
     nombre: LLMChain(modelo, caché) for nombre, modelo, caché in zip(modelos.keys(), modelos.values(), caches.values())
 }
 
-print("Creando instancias de cadenas de modelo...")
-for nombre, cadena in tqdm(cadenas.items()):
-    print(f"Cadena de modelo {nombre} creada")
-
 summarizer = pipeline("summarization", device=device)
 
-print("Cargando modelo de resumen de texto...")
-
 vectorizer = TfidfVectorizer()
 
-print("Cargando modelo de vectorizador TF-IDF...")
-
-dalle_encoder = eBart.from_pretrained(model_id="dalle-mini/dalle-mini")
-dalle_decoder = eBart.from_pretrained(model_id="dalle-mini/dalle-mini")
-
-print("Cargando modelo DALL-E...")
-
 def keep_alive():
     while True:
-        # Realizar una petición a cada modelo cada 5 minutos
         for cadena in cadenas.values():
             try:
                 cadena.ask("¿Cuál es el sentido de la vida?")
@@ -86,39 +66,23 @@ def keep_alive():
 
 def liberar_recursos():
     while True:
-        # Obtener memoria RAM disponible
         memoria_ram = psutil.virtual_memory().available / (1024.0 ** 3)
-        
-        # Obtener espacio en disco disponible
         espacio_disco = psutil.disk_usage('/').free / (1024.0 ** 3)
-        
-        # Verificar si la memoria RAM o espacio en disco es menor al 5%
         if memoria_ram < 5 or espacio_disco < 5:
-            # Liberar memoria RAM
             gc.collect()
-            
-            # Cerrar procesos innecesarios
             for proc in psutil.process_iter(['pid', 'name']):
                 if proc.info['name'] == 'python':
                     os.kill(proc.info['pid'], 9)
-        
         time.sleep(60)
 
 threading.Thread(target=keep_alive, daemon=True).start()
 threading.Thread(target=liberar_recursos, daemon=True).start()
 
-print("Iniciando hilos...")
 @app.post("/pregunta")
 async def pregunta(pregunta: str, modelo: str):
-    print(f"Pregunta recibida: {pregunta}, Modelo: {modelo}")
     try:
-        # Obtener respuesta del modelo seleccionado
         respuesta = cadenas[modelo].ask(pregunta)
-        print(f"Respuesta obtenida: {respuesta}")
-        
-        # Verificar si la respuesta excede el límite de tokens máximos
-        if len(respuesta.split()) > 2048:  
-            # Dividir la respuesta en varios mensajes
+        if len(respuesta.split()) > 2048:
             mensajes = []
             palabras = respuesta.split()
             mensaje_actual = ""
@@ -129,20 +93,12 @@ async def pregunta(pregunta: str, modelo: str):
                 else:
                     mensaje_actual += " " + palabra
             mensajes.append(mensaje_actual)
-            
-            # Retornar los mensajes divididos
             return {"respuestas": mensajes}
         else:
-            # Obtener resumen de respuesta
             resumen = summarizer(respuesta, max_length=50, min_length=5, do_sample=False)
-            print(f"Resumen obtenido: {resumen[0]['summary_text']}")
-            
-            # Calcular similitud entre pregunta y respuesta
             pregunta_vec = vectorizer.fit_transform([pregunta])
             respuesta_vec = vectorizer.transform([respuesta])
             similitud = cosine_similarity(pregunta_vec, respuesta_vec)
-            print(f"Similitud calculada: {similitud[0][0]}")
-            
             return {
                 "respuesta": respuesta,
                 "resumen": resumen[0]["summary_text"],
@@ -154,12 +110,8 @@ async def pregunta(pregunta: str, modelo: str):
 
 @app.post("/resumen")
 async def resumen(texto: str):
-    print(f"Texto recibido: {texto}")
     try:
-        # Obtener resumen de texto
         resumen = summarizer(texto, max_length=50, min_length=5, do_sample=False)
-        print(f"Resumen obtenido: {resumen[0]['summary_text']}")
-        
         return {"resumen": resumen[0]["summary_text"]}
     except Exception as e:
         logging.error(f"Error en resumen: {e}")
@@ -167,50 +119,22 @@ async def resumen(texto: str):
 
 @app.post("/similitud")
 async def similitud(texto1: str, texto2: str):
-    print(f"Textos recibidos: {texto1}, {texto2}")
-    try:
-        # Calcular similitud entre dos textos
-        texto1_vec = vectorizer.fit_transform([texto1])
-        texto2_vec = vectorizer.transform([texto2])
-        similitud = cosine_similarity(texto1_vec, texto2_vec)
-        print(f"Similitud calculada: {similitud[0][0]}")
-        
-        return {"similitud": similitud[0][0]}
-    except Exception as e:
-        logging.error(f"Error en similitud: {e}")
-        return {"error": "Error en similitud"}
-
-@app.post("/imagen")
-async def imagen(texto: str):
-    print(f"Texto recibido: {texto}")
-    try:
-        # Obtener imagen a partir del texto
-        imagen = dalle_decoder.generate_images(texto, num_images=1)
-        print(f"Imagen generada")
-        
-        # Generar nombre aleatorio para el archivo
-        nombre_archivo = f"{uuid.uuid4()}.png"
-        print(f"Nombre de archivo: {nombre_archivo}")
-        
-        # Guardar imagen en archivo
-        imagen.save(nombre_archivo)
-        print(f"Imagen guardada en {nombre_archivo}")
-        
-        return {"imagen": nombre_archivo}
-    except Exception as e:
-        logging.error(f"Error en imagen: {e}")
-        return {"error": "Error en imagen"}
+try:
+texto1_vec = vectorizer.fit_transform([texto1])
+texto2_vec = vectorizer.transform([texto2])
+similitud = cosine_similarity(texto1_vec, texto2_vec)
+return {"similitud": similitud[0][0]}
+except Exception as e:
+logging.error(f"Error en similitud: {e}")
+return {"error": "Error en similitud"}
 
 @app.get("/modelos")
 async def modelos():
-    print("Modelos solicitados")
-    return {"modelos": list(cadenas.keys())}
+return {"modelos": list(cadenas.keys())}
 
 @app.get("/estado")
 async def estado():
-    print("Estado solicitado")
-    return {"estado": "activo"}
+return {"estado": "activo"}
 
 if __name__ == "__main__":
-    print("Iniciando API...")
     uvicorn.run(app, host="0.0.0.0", port=8000)