Update app.py

app.py

@@ -1,27 +1,27 @@
+import os
 from pydantic import BaseModel
 from llama_cpp import Llama
 from concurrent.futures import ThreadPoolExecutor, as_completed
 import re
 import gradio as gr
-import os
-import urllib3
-import pickle
-from functools import lru_cache
 from dotenv import load_dotenv
 from fastapi import FastAPI, Request, HTTPException
 from fastapi.responses import JSONResponse
 from tqdm import tqdm
+from functools import lru_cache
+import urllib3
 
 urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
 
+# Instalar la librería llama-cpp-python
+os.system("pip install llama-cpp-python")
+
 app = FastAPI()
 load_dotenv()
 HUGGINGFACE_TOKEN = os.getenv("HUGGINGFACE_TOKEN")
 
+# Configuración de modelos globales
 global_data = {
-    'tokens': {'eos': 'eos_token', 'pad': 'pad_token', 'padding': 'padding_token',
-               'unk': 'unk_token', 'bos': 'bos_token', 'sep': 'sep_token',
-               'cls': 'cls_token', 'mask': 'mask_token'},
     'model_configs': [
         {"repo_id": "Ffftdtd5dtft/gpt2-xl-Q2_K-GGUF", "filename": "gpt2-xl-q2_k.gguf", "name": "GPT-2 XL"},
         {"repo_id": "Ffftdtd5dtft/gemma-2-27b-Q2_K-GGUF", "filename": "gemma-2-27b-q2_k.gguf", "name": "Gemma 2-27B"},
@@ -36,14 +36,10 @@ global_data = {
     ]
 }
 
-response_cache = {}
-model_cache_dir = "model_cache"
-os.makedirs(model_cache_dir, exist_ok=True)
-
+# Manejo de la carga de modelos
 class ModelManager:
     def __init__(self):
         self.models = {}
-        self.model_cache_dir = model_cache_dir
         self.load_all_models()
 
     def load_all_models(self):
@@ -54,16 +50,9 @@ class ModelManager:
 
     def _load_model(self, model_config):
         model_name = model_config['name']
-        cache_file = os.path.join(self.model_cache_dir, f"{model_name}.pkl")
         if model_name not in self.models:
             try:
-                if os.path.exists(cache_file):
-                    with open(cache_file, "rb") as f:
-                        self.models[model_name] = pickle.load(f)
-                else:
-                    self.models[model_name] = Llama.from_pretrained(repo_id=model_config['repo_id'], filename=model_config['filename'], use_auth_token=HUGGINGFACE_TOKEN)
-                    with open(cache_file, "wb") as f:
-                        pickle.dump(self.models[model_name], f)
+                self.models[model_name] = Llama.from_pretrained(repo_id=model_config['repo_id'], filename=model_config['filename'], use_auth_token=HUGGINGFACE_TOKEN)
             except Exception as e:
                 print(f"Error loading {model_name}: {e}")
                 self.models[model_name] = None
@@ -76,9 +65,11 @@ model_manager = ModelManager()
 class ChatRequest(BaseModel):
     message: str
 
+# Normalización de entrada
 def normalize_input(input_text):
     return input_text.strip()
 
+# Eliminación de duplicados en la respuesta
 def remove_duplicates(text):
     text = re.sub(r'(Hello there, how are you\? \[/INST\]){2,}', 'Hello there, how are you?', text)
     text = re.sub(r'(How are you\? \[/INST\]){2,}', 'How are you?', text)
@@ -92,6 +83,7 @@ def remove_duplicates(text):
             seen_lines.add(line)
     return '\n'.join(unique_lines)
 
+# Generación de respuesta de modelo
 @lru_cache(maxsize=128)
 def generate_model_response(model, inputs):
     try:
@@ -101,11 +93,9 @@ def generate_model_response(model, inputs):
         print(f"Error generating response: {e}")
         return f"Error: Could not generate a response. Details: {e}"
 
+# Procesamiento del mensaje
 async def process_message(message):
     inputs = normalize_input(message)
-    if inputs in response_cache:
-        return response_cache[inputs]
-
     responses = {}
 
     with ThreadPoolExecutor(max_workers=len(global_data['model_configs'])) as executor:
@@ -114,9 +104,7 @@ async def process_message(message):
             model_name = global_data['model_configs'][i]['name']
             responses[model_name] = future.result()
 
-    formatted_response = "\n\n".join([f"**{model}:**\n{response}" for model, response in responses.items()])
-    response_cache[inputs] = formatted_response
-    return formatted_response
+    return "\n\n".join([f"**{model}:**\n{response}" for model, response in responses.items()])
 
 @app.post("/generate_multimodel")
 async def api_generate_multimodel(request: Request):
@@ -132,6 +120,7 @@ async def api_generate_multimodel(request: Request):
     except Exception as e:
         return JSONResponse({"error": str(e)}, status_code=500)
 
+# Interfaz Gradio
 iface = gr.Interface(
     fn=process_message,
     inputs=gr.Textbox(lines=2, placeholder="Enter your message here..."),
@@ -141,6 +130,7 @@ iface = gr.Interface(
     live=False
 )
 
+# Lanzar servidor
 if __name__ == "__main__":
     port = int(os.environ.get("PORT", 7860))
     iface.launch(server_port=port)