Update app.py

app.py

@@ -4,7 +4,7 @@ from sklearn.metrics.pairwise import cosine_similarity
 import numpy as np
 import gradio as gr
 
-# Load GPT-2 and tokenizer
+# Load model + tokenizer
 model_name = "gpt2"
 tokenizer = GPT2Tokenizer.from_pretrained(model_name)
 model = GPT2LMHeadModel.from_pretrained(model_name)
@@ -12,7 +12,7 @@ model.eval()
 device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 model.to(device)
 
-# Function to generate response
+# Generate response with visible prompt/response formatting
 def generate_response(prompt, max_length=100):
     inputs = tokenizer(prompt, return_tensors="pt").to(device)
     outputs = model.generate(
@@ -25,7 +25,7 @@ def generate_response(prompt, max_length=100):
     )
     return tokenizer.decode(outputs[0], skip_special_tokens=True).strip()
 
-# Semantic similarity via mean embeddings (ΔS approximation)
+# Cosine similarity to estimate ΔS
 def similarity(a, b):
     tok_a = tokenizer(a, return_tensors="pt").to(device)
     tok_b = tokenizer(b, return_tensors="pt").to(device)
@@ -34,47 +34,54 @@ def similarity(a, b):
         emb_b = model.transformer.wte(tok_b.input_ids).mean(dim=1)
     return float(cosine_similarity(emb_a.cpu().numpy(), emb_b.cpu().numpy())[0][0])
 
-# Recursive identity loop (EAL-style unfolding)
-def identity_unfolding(steps):
+# Main loop: identity unfolding
+def identity_unfolding(n_steps):
     unfolding = []
     ΔS_trace = []
+    log = []
 
-    current_text = "The following is a system thinking about itself:\n"
+    current_prompt = "The following is a system thinking about itself:\n"
 
-    for step in range(steps):
-        response = generate_response(current_text)
+    for step in range(n_steps):
+        log.append(f"--- Step {step} ---")
+        log.append(f"[Prompt to GPT-2]:\n{current_prompt}")
+
+        response = generate_response(current_prompt)
         unfolding.append(response)
 
+        log.append(f"[GPT-2 Response]:\n{response}")
+
         if step > 0:
             ΔS = similarity(unfolding[step - 1], unfolding[step])
             ΔS_trace.append(round(ΔS, 4))
+            log.append(f"ΔS({step - 1} → {step}) = {round(ΔS, 4)}\n")
+        else:
+            log.append("ΔS not applicable for first step.\n")
 
-        current_text = (
+        current_prompt = (
             f'The system has previously stated:\n"{response}"\n'
             "Now it continues thinking about what that implies:\n"
         )
 
-    results = "\n\n---\n\n".join(
-        [f"Step {i}: {txt}" for i, txt in enumerate(unfolding)]
-    )
-    sim = "\n".join(
-        [f"ΔS({i} → {i+1}) = {val}" for i, val in enumerate(ΔS_trace)]
+    summary = "\n".join(log)
+    trace_summary = "\n".join(
+        [f"ΔS({i} → {i+1}) = {ΔS_trace[i]}" for i in range(len(ΔS_trace))]
     )
-    return results, sim
+    return summary, trace_summary
 
-# Gradio Interface
+# Gradio interface
 iface = gr.Interface(
     fn=identity_unfolding,
-    inputs=gr.Slider(2, 10, value=5, step=1, label="Number of Iterations"),
+    inputs=gr.Slider(2, 10, value=5, step=1, label="Number of Identity Iterations"),
     outputs=[
-        gr.Textbox(label="GPT-2 Identity Trace", lines=20),
-        gr.Textbox(label="Semantic ΔS Trace", lines=10),
+        gr.Textbox(label="Full Trace (Prompts + GPT-2 Outputs)", lines=25),
+        gr.Textbox(label="ΔS Semantic Similarity Trace", lines=10),
     ],
-    title="EAL Identity Tester for GPT-2",
+    title="GPT-2 Identity Emergence Analyzer (EAL Framework)",
     description=(
-        "This app recursively prompts GPT-2 to reflect on its own output. "
-        "It shows how close each iteration is to the previous one using a cosine-based ΔS metric. "
-        "Use this to test if GPT-2 stabilizes around a semantically coherent self-representation."
+        "This app tests whether GPT-2 can recursively reflect on its own outputs. "
+        "It uses prompt-based recursion and cosine similarity (ΔS) to measure semantic stability across iterations. "
+        "A stabilizing identity shows high ΔS values close to 1.0 across iterations."
     ),
 )