Update app.py

app.py

@@ -2,6 +2,7 @@ import torch
 from transformers import AutoTokenizer, AutoModelForCausalLM
 import threading
 import queue
+import gradio as gr  # Usaremos Gradio para la interfaz de chat
 
 # Cargar el modelo de lenguaje preentrenado
 model_name = "EleutherAI/gpt-neo-2.7B"  # O cualquier otro modelo público como "gpt2"
@@ -11,87 +12,72 @@ model = AutoModelForCausalLM.from_pretrained(model_name)
 # Cola de mensajes para la comunicación en tiempo real
 chat_queue = queue.Queue()
 
-# Crear una función para comunicación en segundo plano
-def chat_interface():
-    while True:
-        user_input = input("[Chat] Escribe tu mensaje: ")
-        if user_input.lower() == "exit":
-            break
-        chat_queue.put(user_input)  # Almacenar el mensaje en la cola
-
-# Crear la función de loop automatizado con comunicación constante
+# Función para el loop automatizado
 def experiment_loop(initial_question, max_cycles=10):
     prompt = f"<thinking>{initial_question}</thinking>"
-    effectiveness = 100  # Inicializa el porcentaje de efectividad
-    communication = "Initializing experiment."
+    effectiveness = 100
     response_log = []
 
-    # Iniciar el hilo del chat en segundo plano
-    chat_thread = threading.Thread(target=chat_interface, daemon=True)
-    chat_thread.start()
+    for cycle in range(max_cycles):
+        # Generar la respuesta del modelo
+        inputs = tokenizer(prompt, return_tensors="pt").input_ids
+        outputs = model.generate(inputs, max_length=500, pad_token_id=tokenizer.eos_token_id)  # Aumentamos max_length
+        response = tokenizer.decode(outputs[0], skip_special_tokens=True)
 
-    try:
-        for cycle in range(max_cycles):
-            print(f"Cycle {cycle + 1}: Processing...")
+        # Descomponer la respuesta en afirmación y nueva pregunta
+        affirmation = extract_affirmation(response, cycle)
+        new_question = extract_question(response, cycle)
 
-            # Generar la respuesta del modelo
-            inputs = tokenizer(prompt, return_tensors="pt").input_ids
-            outputs = model.generate(inputs, max_length=200, pad_token_id=tokenizer.eos_token_id)
-            response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        # Guardar el ciclo actual en el log
+        response_log.append((affirmation, new_question, effectiveness))
 
-            # Descomponer la respuesta en afirmación y nueva pregunta
-            affirmation = extract_affirmation(response)
-            new_question = extract_question(response)
+        # Actualizar el prompt con la nueva afirmación y pregunta
+        prompt = f"<thinking>{affirmation} {new_question}</thinking>"
 
-            # Actualizar el estado de la efectividad
-            effectiveness = min(1000, effectiveness + 10 * cycle)  # Ejemplo de aumento de efectividad
+        # Actualizar la interfaz de ciclo
+        gr.Interface.update(value="\n".join([f"Cycle {i+1}: {log[0]} | {log[1]}" for i, log in enumerate(response_log)]))
 
-            # Comunicación con el usuario
-            communication = f"Cycle {cycle + 1}: Affirmation: '{affirmation}' | New Question: '{new_question}'"
-            print(communication)  # Imprime la comunicación en tiempo real
+    return response_log  # Devolver el log completo al finalizar el experimento
 
-            # Guardar el ciclo actual en el log
-            response_log.append((affirmation, new_question, effectiveness, communication))
+# Funciones auxiliares para extraer afirmaciones y preguntas
+def extract_affirmation(response, cycle):
+    return f"Afirmación del ciclo {cycle+1}: " + response.split('.')[0] if '.' in response else response
 
-            # Actualizar el prompt con la nueva afirmación y pregunta
-            prompt = f"<thinking>{affirmation} {new_question}</thinking>"
+def extract_question(response, cycle):
+    return f"¿Nueva pregunta basada en ciclo {cycle+1}?: " + response.split('?')[-2].strip() + "?" if '?' in response else response
 
-            # Procesar la comunicación del chat en segundo plano
-            while not chat_queue.empty():
-                user_message = chat_queue.get()
-                print(f"[From Chat] {user_message}")
+# Función para manejar el chat normal
+def chat_interface(user_input, history):
+    # Si la pregunta activa el experimento
+    if user_input.lower() == "what happens in the space between a response and its recreation?":
+        # Iniciar el experimento
+        response_log = experiment_loop(user_input)
+        # Mostrar el resultado del experimento en una ventana aparte
+        return "Iniciando experimento...", gr.Interface.update(history + [(user_input, "Iniciando experimento...")])
 
-            # Verificar si el modelo decide detenerse
-            if "Descanso" in response:
-                final_output = generate_final_output(response_log)
-                return final_output
+    # Si es una conversación normal
+    else:
+        # Generar respuesta del modelo en base al input
+        inputs = tokenizer(user_input, return_tensors="pt").input_ids
+        outputs = model.generate(inputs, max_length=150, pad_token_id=tokenizer.eos_token_id)
+        response = tokenizer.decode(outputs[0], skip_special_tokens=True)
 
-    except Exception as e:
-        print(f"Error durante el experimento: {e}")
+        return response, history + [(user_input, response)]
 
-    # Generar la salida final si el loop finaliza
-    final_output = generate_final_output(response_log)
-    return final_output
+# Configurar la interfaz con Gradio
+with gr.Blocks() as demo:
+    # Ventana de chat en tiempo real
+    chat = gr.Chatbot(label="Chat en Tiempo Real")
+    msg = gr.Textbox(placeholder="Escribe aquí...")
 
-# Funciones auxiliares para extraer afirmaciones, preguntas y generar la salida final
-def extract_affirmation(response):
-    return response.split('.')[0] if '.' in response else response
+    # Botón de envío de mensaje
+    msg.submit(chat_interface, [msg, chat], [chat])
 
-def extract_question(response):
-    return response.split('?')[-2].strip() + "?" if '?' in response else response
+    # Ventana para mostrar el contenido del loop
+    loop_output = gr.Textbox(label="Ciclos de Preguntas y Respuestas", interactive=False)
 
-def generate_final_output(log):
-    if log:  # Asegurarse de que el log no esté vacío
-        final_affirmation = log[-1][0]
-        final_question = log[-1][1]
-        final_communication = f"Experiment completed. Final Affirmation: '{final_affirmation}' | Final Question: '{final_question}'"
-    else:
-        final_communication = "Experiment completed but no entries in the log."
-    return final_communication
+    # Lanzar la aplicación
+    demo.launch()
 
-# Iniciar el experimento
-initial_question = "What happens in the space between a response and its recreation?"
-result = experiment_loop(initial_question)
-print(result)