Update app.py

app.py

@@ -1,11 +1,12 @@
 from fastapi import FastAPI, HTTPException
 from pydantic import BaseModel
 from llama_cpp import Llama
-from concurrent.futures import ThreadPoolExecutor, as_completed
+from concurrent.futures import ProcessPoolExecutor, as_completed
 import uvicorn
 from dotenv import load_dotenv
 from difflib import SequenceMatcher
 from tqdm import tqdm
+import multiprocessing
 
 load_dotenv()
 
@@ -19,9 +20,26 @@ models = [
     {"repo_id": "Ffftdtd5dtft/gemma-2-27b-Q2_K-GGUF", "filename": "gemma-2-27b-q2_k.gguf"},
 ]
 
-# Cargar modelos en RAM solo una vez
-llms = [Llama.from_pretrained(repo_id=model['repo_id'], filename=model['filename']) for model in models]
-print(f"Modelos cargados en RAM: {[model['repo_id'] for model in models]}")
+# Función para cargar un modelo
+def load_model(model_config):
+    return Llama.from_pretrained(repo_id=model_config['repo_id'], filename=model_config['filename'])
+
+# Cargar modelos en paralelo
+def load_all_models():
+    with ProcessPoolExecutor() as executor:
+        future_to_model = {executor.submit(load_model, model): model for model in models}
+        loaded_models = {}
+        for future in as_completed(future_to_model):
+            model = future_to_model[future]
+            try:
+                loaded_models[model['repo_id']] = future.result()
+                print(f"Modelo cargado en RAM: {model['repo_id']}")
+            except Exception as exc:
+                print(f"Error al cargar modelo {model['repo_id']}: {exc}")
+    return loaded_models
+
+# Cargar modelos en memoria
+llms = load_all_models()
 
 class ChatRequest(BaseModel):
     message: str
@@ -46,9 +64,24 @@ def generate_chat_response(request, llm):
 def normalize_input(input_text):
     return input_text.strip()
 
+def filter_duplicates(responses):
+    seen = set()
+    unique_responses = []
+    for response in responses:
+        lines = response.split('\n')
+        unique_lines = set()
+        for line in lines:
+            if line not in seen:
+                seen.add(line)
+                unique_lines.add(line)
+        unique_responses.append('\n'.join(unique_lines))
+    return unique_responses
+
 def select_best_response(responses):
+    # Eliminar respuestas duplicadas
+    unique_responses = filter_duplicates(responses)
     # Deduplicar respuestas
-    unique_responses = list(set(responses))
+    unique_responses = list(set(unique_responses))
     # Filtrar respuestas coherentes
     coherent_responses = filter_by_coherence(unique_responses)
     # Seleccionar la mejor respuesta
@@ -76,33 +109,27 @@ async def generate_chat(request: ChatRequest):
     
     print(f"Procesando solicitud: {request.message}")
 
-    # Utilizar un ThreadPoolExecutor para procesar los modelos en paralelo
-    with ThreadPoolExecutor() as executor:
-        futures = [executor.submit(generate_chat_response, request, llm) for llm in llms]
+    # Utilizar un ProcessPoolExecutor para procesar los modelos en paralelo
+    def worker_function(llm):
+        return generate_chat_response(request, llm)
+    
+    with ProcessPoolExecutor() as executor:
+        futures = [executor.submit(worker_function, llm) for llm in llms.values()]
         responses = []
 
         for future in tqdm(as_completed(futures), total=len(futures), desc="Generando respuestas"):
             response = future.result()
-            responses.append(response)
+            responses.append(response['response'])
             print(f"Modelo procesado: {response['literal'][:30]}...")
 
-    # Extraer respuestas de los diccionarios
-    response_texts = [resp['response'] for resp in responses]
-    
-    # Verificar si hay errores en las respuestas
-    error_responses = [resp for resp in responses if "Error" in resp['response']]
-    if error_responses:
-        error_response = error_responses[0]
-        raise HTTPException(status_code=500, detail=error_response['response'])
-    
     # Seleccionar la mejor respuesta
-    best_response = select_best_response(response_texts)
+    best_response = select_best_response(responses)
     
     print(f"Mejor respuesta seleccionada: {best_response}")
 
     return {
         "best_response": best_response,
-        "all_responses": response_texts
+        "all_responses": responses
     }
 
 if __name__ == "__main__":