Update app.py

app.py

@@ -2,7 +2,6 @@ import os
 import logging
 import asyncio
 import uvicorn
-import torch
 import random
 from transformers import AutoModelForCausalLM, AutoTokenizer
 from fastapi import FastAPI, Query, HTTPException
@@ -33,20 +32,23 @@ async def load_models():
     ]
     gpt_models = ["gpt2-medium", "gpt2-large", "gpt2", "gemma-2-9b", "starcoder"] + programming_models
     
+    models = []
     for model_name in gpt_models:
         try:
             model = AutoModelForCausalLM.from_pretrained(model_name)
             tokenizer = AutoTokenizer.from_pretrained(model_name)
             logger.info(f"Successfully loaded {model_name} model")
-            return model, tokenizer
+            models.append((model, tokenizer, model_name))
         except Exception as e:
             logger.error(f"Failed to load {model_name} model: {e}")
-    raise HTTPException(status_code=500, detail="Failed to load any models")
+    if not models:
+        raise HTTPException(status_code=500, detail="Failed to load any models")
+    return models
 
 # Función para descargar modelos
 async def download_models():
-    model, tokenizer = await load_models()
-    data_and_models_dict['model'] = (model, tokenizer)
+    models = await load_models()
+    data_and_models_dict['models'] = models
 
 @app.get('/')
 async def main():
@@ -153,9 +155,9 @@ async def main():
 
                 saveMessage('user', userMessage);
                 await fetch(`/autocomplete?q=${userMessage}`)
-                    .then(response => response.text())
+                    .then(response => response.json())
                     .then(data => {
-                        saveMessage('bot', data);
+                        saveMessage('bot', data.response);
                         chatBox.scrollTop = chatBox.scrollHeight;
                     })
                     .catch(error => console.error('Error:', error));
@@ -179,35 +181,47 @@ async def autocomplete(q: str = Query(...)):
     global data_and_models_dict, message_history, tokens_history
 
     # Verificar si hay modelos cargados
-    if 'model' not in data_and_models_dict:
+    if 'models' not in data_and_models_dict:
         await download_models()
 
-    # Cargar el modelo y el tokenizer
-    model, tokenizer = data_and_models_dict['model']
+    # Obtener los modelos
+    models = data_and_models_dict['models']
     
-    # Generar tokens de entrada
-    input_ids = tokenizer.encode(q, return_tensors="pt")
-    tokens_history.append({"input": input_ids.tolist()})  # Guardar tokens de entrada
-
-    # Generar parámetros aleatorios
-    top_k = random.randint(0, 50)
-    top_p = random.uniform(0.8, 1.0)
-    temperature = random.uniform(0.7, 1.5)
-
-    # Generar una respuesta utilizando el modelo
-    output = model.generate(
-        input_ids,
-        max_length=50,
-        top_k=top_k,
-        top_p=top_p,
-        temperature=temperature,
-        num_return_sequences=1
-    )
-    response_text = tokenizer.decode(output[0], skip_special_tokens=True)
-
-    # Generar tokens de salida
-    output_ids = output[0].tolist()
-    tokens_history.append({"output": output_ids})  # Guardar tokens de salida
+    best_response = None
+    best_score = float('-inf')  # Para almacenar la mejor puntuación
+
+    for model, tokenizer, model_name in models:
+        # Generar tokens de entrada
+        input_ids = tokenizer.encode(q, return_tensors="pt")
+        tokens_history.append({"input": input_ids.tolist()})  # Guardar tokens de entrada
+
+        # Generar parámetros aleatorios
+        top_k = random.randint(0, 50)
+        top_p = random.uniform(0.8, 1.0)
+        temperature = random.uniform(0.7, 1.5)
+
+        # Generar una respuesta utilizando el modelo
+        output = model.generate(
+            input_ids,
+            max_length=50,
+            top_k=top_k,
+            top_p=top_p,
+            temperature=temperature,
+            num_return_sequences=1
+        )
+        response_text = tokenizer.decode(output[0], skip_special_tokens=True)
+
+        # Calcular una puntuación simple para determinar la mejor respuesta
+        score = len(response_text)  # Aquí podrías usar otro criterio de puntuación
+
+        # Comparar y almacenar la mejor respuesta
+        if score > best_score:
+            best_score = score
+            best_response = response_text
+
+        # Generar tokens de salida
+        output_ids = output[0].tolist()
+        tokens_history.append({"output": output_ids})  # Guardar tokens de salida
 
     # Guardar eos y pad tokens
     eos_token = tokenizer.eos_token_id
@@ -217,12 +231,13 @@ async def autocomplete(q: str = Query(...)):
     # Guardar el mensaje del usuario en el historial
     message_history.append(q)
 
-    return response_text
+    # Respuesta con la mejor respuesta generada
+    return {"response": best_response}
 
 # Función para ejecutar la aplicación sin reiniciarla
 def run_app():
     asyncio.run(download_models())
-    uvicorn.run(app, host='0.0.0.0', port=4443)
+    uvicorn.run(app, host='0.0.0.0', port=7860)
 
 # Ejecutar la aplicación
 if __name__ == "__main__":