app.py

import torch
from transformers import pipeline, AutoTokenizer, AutoModelForCausalLM

# Cargar el modelo de lenguaje preentrenado
model_name = "gpt2"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)

# Crear la función de 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."
    response_log = []

    try:
        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=200)
            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}'"

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

            # Verificar si el modelo decide detenerse
            if "Descanso" in response:
                final_output = generate_final_output(response_log)
                return final_output
            
            # Actualizar el prompt con la nueva afirmación y pregunta
            prompt = f"<thinking>{affirmation} {new_question}</thinking>"

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

    # Si se alcanza el número máximo de ciclos sin detenerse
    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):
    # Lógica para extraer la afirmación de la respuesta
    return response.split('.')[0]

def extract_question(response):
    # Lógica para extraer la nueva pregunta de la respuesta
    return response.split('?')[-2].strip() + "?"

def generate_final_output(log):
    final_affirmation = log[-1][0]
    final_question = log[-1][1]
    final_communication = f"Experiment completed. Final Affirmation: '{final_affirmation}' | Final Question: '{final_question}'"
    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)
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

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

# 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 = []

    try:
        for cycle in range(max_cycles):
            # Comunicación continua contigo durante el loop
            print(f"Cycle {cycle + 1}: Processing...")

            # Simulación de espera para permitir la interacción
            input_check = input("Would you like to communicate or check the current state? (yes/no): ")
            if input_check.lower() == "yes":
                print(f"Current state: Effectiveness = {effectiveness}, Communication = {communication}")

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

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

            # Verificar si el modelo decide detenerse
            if "Descanso" in response:
                final_output = generate_final_output(response_log)
                return final_output
            
            # Actualizar el prompt con la nueva afirmación y pregunta
            prompt = f"<thinking>{affirmation} {new_question}</thinking>"

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

    # Si se alcanza el número máximo de ciclos sin detenerse
    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]

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

def generate_final_output(log):
    final_affirmation = log[-1][0]
    final_question = log[-1][1]
    final_communication = f"Experiment completed. Final Affirmation: '{final_affirmation}' | Final Question: '{final_question}'"
    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)