Update app.py

app.py

@@ -6,50 +6,68 @@ from tqdm import tqdm
 import uvicorn
 from dotenv import load_dotenv
 from difflib import SequenceMatcher
-import threading
+import re
 
+# Cargar variables de entorno
 load_dotenv()
 
+# Inicializar aplicación FastAPI
 app = FastAPI()
 
+# Diccionario global para almacenar los modelos
+global_data = {
+    'models': []
+}
+
 # Configuración de los modelos
 model_configs = [
     {"repo_id": "Ffftdtd5dtft/gpt2-xl-Q2_K-GGUF", "filename": "gpt2-xl-q2_k.gguf"},
     {"repo_id": "Ffftdtd5dtft/Meta-Llama-3.1-8B-Instruct-Q2_K-GGUF", "filename": "meta-llama-3.1-8b-instruct-q2_k.gguf"},
     {"repo_id": "Ffftdtd5dtft/gemma-2-9b-it-Q2_K-GGUF", "filename": "gemma-2-9b-it-q2_k.gguf"},
+    {"repo_id": "Ffftdtd5dtft/gemma-2-27b-Q2_K-GGUF", "filename": "gemma-2-27b-q2_k.gguf"},
     {"repo_id": "Ffftdtd5dtft/Phi-3-mini-128k-instruct-Q2_K-GGUF", "filename": "phi-3-mini-128k-instruct-q2_k.gguf"},
     {"repo_id": "Ffftdtd5dtft/Meta-Llama-3.1-8B-Q2_K-GGUF", "filename": "meta-llama-3.1-8b-q2_k.gguf"},
+    {"repo_id": "Ffftdtd5dtft/Qwen2-7B-Instruct-Q2_K-GGUF", "filename": "qwen2-7b-instruct-q2_k.gguf"},
     {"repo_id": "Ffftdtd5dtft/starcoder2-3b-Q2_K-GGUF", "filename": "starcoder2-3b-q2_k.gguf"},
-    {"repo_id": "Ffftdtd5dtft/Qwen2-1.5B-Instruct-Q2_K-GGUF", "filename": "qwen2-1.5b-instruct-q2_k.gguf"},
+    {"repo_id": "Ffftdtd5dtft/Qwen2-1.5B-Instruct-Q2_K-GGUF", "filename": "qwen2-1.5b-instruct-q2_k.gguf"}
 ]
 
-def load_model(model_config):
-    print(f"Cargando modelo {model_config['repo_id']}...")
-    return Llama.from_pretrained(repo_id=model_config['repo_id'], filename=model_config['filename'])
-
-def load_all_models():
-    print("Iniciando carga de modelos...")
-    with ThreadPoolExecutor(max_workers=len(model_configs)) as executor:
-        futures = [executor.submit(load_model, config) for config in model_configs]
-        models = []
-        for future in tqdm(as_completed(futures), total=len(model_configs), desc="Cargando modelos", unit="modelo"):
-            try:
-                model = future.result()
-                models.append(model)
-                print(f"Modelo cargado exitosamente: {model_configs[len(models)-1]['repo_id']}")
-            except Exception as e:
-                print(f"Error al cargar el modelo: {e}")
-    print("Todos los modelos han sido cargados.")
-    return models
-
-llms = load_all_models()
-
+# Clase para gestionar modelos
+class ModelManager:
+    def __init__(self):
+        self.models = []
+    
+    def load_model(self, model_config):
+        print(f"Cargando modelo {model_config['repo_id']}...")
+        return Llama.from_pretrained(repo_id=model_config['repo_id'], filename=model_config['filename'])
+    
+    def load_all_models(self):
+        print("Iniciando carga de modelos...")
+        with ThreadPoolExecutor(max_workers=len(model_configs)) as executor:
+            futures = [executor.submit(self.load_model, config) for config in model_configs]
+            models = []
+            for future in tqdm(as_completed(futures), total=len(model_configs), desc="Cargando modelos", unit="modelo"):
+                try:
+                    model = future.result()
+                    models.append(model)
+                    print(f"Modelo cargado exitosamente: {model_configs[len(models)-1]['repo_id']}")
+                except Exception as e:
+                    print(f"Error al cargar el modelo: {e}")
+        print("Todos los modelos han sido cargados.")
+        return models
+
+# Instanciar ModelManager y cargar modelos
+model_manager = ModelManager()
+global_data['models'] = model_manager.load_all_models()
+
+# Modelo global para la solicitud de chat
 class ChatRequest(BaseModel):
     message: str
     top_k: int = 50
     top_p: float = 0.95
     temperature: float = 0.7
 
+# Función para generar respuestas de chat
 def generate_chat_response(request, llm):
     try:
         user_input = normalize_input(request.message)
@@ -67,32 +85,48 @@ def generate_chat_response(request, llm):
 def normalize_input(input_text):
     return input_text.strip()
 
-def filter_duplicates(responses):
+def remove_duplicates(text):
+    # Eliminar patrones repetitivos específicos
+    text = re.sub(r'(Hello there, how are you\? \[/INST\]){2,}', 'Hello there, how are you? [/INST]', text)
+    text = re.sub(r'(How are you\? \[/INST\]){2,}', 'How are you? [/INST]', text)
+    
+    # Eliminar el marcador [/INST]
+    text = text.replace('[/INST]', '')
+    
+    # Generaliza la eliminación de duplicados
+    lines = text.split('\n')
+    unique_lines = list(dict.fromkeys(lines))
+    return '\n'.join(unique_lines).strip()
+
+def remove_repetitive_responses(responses):
+    # Filtra respuestas repetitivas
     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))
+        normalized_response = remove_duplicates(response)
+        if normalized_response not in seen:
+            seen.add(normalized_response)
+            unique_responses.append(normalized_response)
     return unique_responses
 
 def select_best_response(responses):
     print("Filtrando respuestas...")
-    unique_responses = filter_duplicates(responses)
-    unique_responses = list(set(unique_responses))
+    responses = remove_repetitive_responses(responses)
+    responses = [remove_duplicates(response) for response in responses]
+    unique_responses = list(set(responses))
     coherent_responses = filter_by_coherence(unique_responses)
     best_response = filter_by_similarity(coherent_responses)
     return best_response
 
 def filter_by_coherence(responses):
-    # Implementa aquí un filtro de coherencia si es necesario
+    # Ordenar respuestas por longitud y similaridad para coherencia básica
+    print("Ordenando respuestas por coherencia...")
+    responses.sort(key=len, reverse=True)
     return responses
 
 def filter_by_similarity(responses):
+    # Seleccionar la respuesta más coherente y única
+    print("Filtrando respuestas por similitud...")
     responses.sort(key=len, reverse=True)
     best_response = responses[0]
     for i in range(1, len(responses)):
@@ -103,7 +137,7 @@ def filter_by_similarity(responses):
     return best_response
 
 def worker_function(llm, request, progress_bar):
-    print(f"Generando respuesta con el modelo...")
+    print(f"Generando respuesta con el modelo {llm}...")
     response = generate_chat_response(request, llm)
     progress_bar.update(1)
     return response
@@ -116,11 +150,11 @@ async def generate_chat(request: ChatRequest):
     print(f"Procesando solicitud: {request.message}")
 
     responses = []
-    num_models = len(llms)
+    num_models = len(global_data['models'])
 
     with tqdm(total=num_models, desc="Generando respuestas", unit="modelo") as progress_bar:
         with ThreadPoolExecutor(max_workers=num_models) as executor:
-            futures = [executor.submit(worker_function, llm, request, progress_bar) for llm in llms]
+            futures = [executor.submit(worker_function, llm, request, progress_bar) for llm in global_data['models']]
             for future in as_completed(futures):
                 try:
                     response = future.result()