app.py

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM
import threading
import queue

# Cargar el modelo de lenguaje preentrenado
model_name = "EleutherAI/gpt-neo-2.7B"  # O cualquier otro modelo público como "gpt2"
tokenizer = AutoTokenizer.from_pretrained(model_name)
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
def experiment_loop(initial_question, max_cycles=10):
    prompt = f"<thinking>{initial_question}</thinking>"
    effectiveness = 100  # Inicializa el porcentaje de efectividad
    communication = "Initializing experiment."
    response_log = []

    # Iniciar el hilo del chat en segundo plano
    chat_thread = threading.Thread(target=chat_interface, daemon=True)
    chat_thread.start()

    try:
        for cycle in range(max_cycles):
            print(f"Cycle {cycle + 1}: Processing...")

            # 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)

            # Descomponer la respuesta en afirmación y nueva pregunta
            affirmation = extract_affirmation(response)
            new_question = extract_question(response)

            # Actualizar el estado de la efectividad
            effectiveness = min(1000, effectiveness + 10 * cycle)  # Ejemplo de aumento de efectividad

            # 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

            # Guardar el ciclo actual en el log
            response_log.append((affirmation, new_question, effectiveness, communication))

            # Actualizar el prompt con la nueva afirmación y pregunta
            prompt = f"<thinking>{affirmation} {new_question}</thinking>"

            # 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}")

            # Verificar si el modelo decide detenerse
            if "Descanso" in response:
                final_output = generate_final_output(response_log)
                return final_output

    except Exception as e:
        print(f"Error durante el experimento: {e}")

    # Generar la salida final si el loop finaliza
    final_output = generate_final_output(response_log)
    return final_output

# Funciones auxiliares para extraer afirmaciones, preguntas y generar la salida final
def extract_affirmation(response):
    return response.split('.')[0] if '.' in response else response

def extract_question(response):
    return response.split('?')[-2].strip() + "?" if '?' in response else response

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

# Iniciar el experimento
initial_question = "What happens in the space between a response and its recreation?"
result = experiment_loop(initial_question)
print(result)