Update app.py

app.py

@@ -2,8 +2,8 @@ import os
 import random
 import gradio as gr
 import wget
+from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
 import whisper
-from gpt4all import GPT4All
 from audiocraft.models import MusicGen
 
 # URLs de los modelos a descargar
@@ -41,11 +41,15 @@ def initialize_whisper():
     model = whisper.load_model("base")
     return model
 
-# Inicializa el chatbot
-def initialize_chatbot(model_files):
-    model_path = random.choice(model_files)  # Selecciona un modelo aleatorio
-    chatbot = GPT4All(model_path=model_path)
-    return chatbot, model_path
+# Inicializa los modelos de transformers
+def initialize_transformer_models():
+    model_names = ["gpt2", "gpt2-medium", "gpt2-large"]  # Puedes agregar más modelos
+    models = []
+    for model_name in model_names:
+        tokenizer = AutoTokenizer.from_pretrained(model_name)
+        model = AutoModelForCausalLM.from_pretrained(model_name)
+        models.append((model, tokenizer))
+    return models
 
 # Función para la generación de canciones con MusicGen
 def generate_song(prompt, model_type="standard"):
@@ -65,32 +69,42 @@ def transcribe_audio(audio_path, whisper_model):
     transcription = whisper_model.transcribe(audio_path)
     return transcription["text"]
 
+# Función para unificar las respuestas de diferentes modelos
+def unified_response(user_input, models):
+    responses = []
+    for model, tokenizer in models:
+        inputs = tokenizer(user_input, return_tensors="pt")
+        outputs = model.generate(**inputs)
+        response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        responses.append(response)
+    
+    # Unificar respuestas (puedes aplicar más lógica aquí, como seleccionar la más común)
+    final_response = random.choice(responses)
+    return final_response
+
 # Función para el chatbot con Gradio
-def chatbot_response(user_input, chatbot, model_path, whisper_model=None, audio_path=None):
+def chatbot_response(user_input, models, whisper_model=None, audio_path=None):
     if user_input.lower() == "salir":
         return "Conexión terminada."
     
-    # Verificar si el modelo es flux1-schnell y debe generar una imagen
-    if "flux1-schnell" in model_path.lower():
-        if "imagen" in user_input.lower():
-            image_path = "output_image.png"
-            chatbot.generate_image(user_input, output=image_path)  # Asumiendo que el chatbot tiene este método
-            return image_path  # Devuelve la ruta de la imagen generada
-        else:
-            return chatbot.chat(user_input)
+    if "imagen" in user_input.lower():
+        return "Funcionalidad de generación de imágenes no soportada por estos modelos."
+
     elif "canción" in user_input.lower() or "musica" in user_input.lower():
         model_type = "medium" if "medium" in user_input.lower() else "standard"
         song_path = generate_song(user_input, model_type=model_type)
         return song_path  # Devuelve la ruta de la canción generada
+
     elif audio_path:  # Si se proporciona un archivo de audio, transcribirlo
         return transcribe_audio(audio_path, whisper_model)
+
     else:
-        return chatbot.chat(user_input)
+        return unified_response(user_input, models)
 
 # Crear la interfaz de Gradio
-def create_gradio_interface(chatbot, model_path, whisper_model):
+def create_gradio_interface(models, whisper_model):
     def gradio_chat(user_input, audio_input=None):
-        response = chatbot_response(user_input, chatbot, model_path, whisper_model, audio_input)
+        response = chatbot_response(user_input, models, whisper_model, audio_input)
         if isinstance(response, str) and response.endswith(".png"):
             return None, response, None, None  # Devuelve None en el texto y la imagen, y ninguna canción
         elif isinstance(response, str) and response.endswith(".wav"):
@@ -99,15 +113,15 @@ def create_gradio_interface(chatbot, model_path, whisper_model):
             return response, None, None, None  # Devuelve el texto, ninguna imagen, ninguna canción, y ninguna transcripción
     
     # Crear interfaz con un input y cuatro outputs (texto, imagen, canción, y transcripción)
-    iface = gr.Interface(fn=gradio_chat, inputs=["text", "audio"], outputs=["text", "image", "audio", "text"], title="Chatbot GPT4All con Imágenes, Canciones, y Transcripción de Audio")
+    iface = gr.Interface(fn=gradio_chat, inputs=["text", "audio"], outputs=["text", "image", "audio", "text"], title="Chatbot con Imágenes, Canciones, y Transcripción de Audio")
     return iface
 
 # Ejecuta el chatbot con Gradio
 def run_chatbot_with_gradio():
     download_models(model_urls, model_files)  # Descargar los modelos si no están presentes
-    chatbot, model_path = initialize_chatbot(model_files)
+    models = initialize_transformer_models()  # Inicializar modelos de Transformers
     whisper_model = initialize_whisper()  # Inicializar el modelo de Whisper
-    iface = create_gradio_interface(chatbot, model_path, whisper_model)
+    iface = create_gradio_interface(models, whisper_model)
     iface.launch()
 
 if __name__ == "__main__":