Upload app.py

app.py

@@ -0,0 +1,156 @@
+"""
+Gradio app for the Brain-like Predictive Coding Code World Model.
+"""
+
+import gradio as gr
+import numpy as np
+import sys
+import os
+
+# Train and load model on startup
+from brain_predictive_coding import PredictiveCodingNetwork, SimpleCodeTokenizer, generate_code
+
+print("Training model...")
+tok = SimpleCodeTokenizer(vocab_size=128)
+
+# Generate and train
+SEQ_LEN = 16
+EMBED = 32
+N_SAMPLES = 40
+EPOCHS = 15
+
+code = generate_code(n=N_SAMPLES, max_len=SEQ_LEN)
+sequences = np.array([tok.embed_seq(tok.encode(c, SEQ_LEN)) for c in code])
+
+net = PredictiveCodingNetwork(
+    embed_dim=EMBED,
+    l1_n=128, l2_n=96, l3_n=64,
+    l1_lr=5e-5, l2_lr=5e-5, l3_lr=5e-5
+)
+
+for epoch in range(EPOCHS):
+    for i in range(N_SAMPLES):
+        net.context = np.zeros_like(net.context)
+        net.process_seq(sequences[i], train=True)
+
+print("Model trained!")
+
+
+def predict_code(code_text, n_steps=5):
+    """Predict next characters in code sequence."""
+    if not code_text:
+        return "Please enter some code!"
+    
+    net.context = np.zeros_like(net.context)
+    
+    tokens = tok.encode(code_text, max_len=16)
+    embeddings = tok.embed_seq(tokens)
+    
+    preds = net.predict_next(embeddings, n_steps=n_steps)
+    predicted_chars = [tok.nearest(p) for p in preds]
+    
+    stats = {
+        "L1 mean activity": float(np.mean(net.l1.activities)),
+        "L1 sparsity": f"{np.mean(net.l1.activities > 0):.1%}",
+        "L2 mean activity": float(np.mean(net.l2.activities)),
+        "L2 sparsity": f"{np.mean(net.l2.activities > 0):.1%}",
+        "L3 mean activity": float(np.mean(net.l3.activities)),
+        "L3 sparsity": f"{np.mean(net.l3.activities > 0):.1%}",
+        "Context magnitude": float(np.linalg.norm(net.context)),
+    }
+    
+    result = f"**Input:** `{code_text}`\n\n"
+    result += f"**Predicted next {n_steps} characters:**\n"
+    for i, ch in enumerate(predicted_chars):
+        result += f"  Step {i+1}: `{ch}`\n"
+    
+    result += f"\n**Brain-like Network Statistics:**\n"
+    for k, v in stats.items():
+        result += f"  {k}: {v}\n"
+    
+    return result
+
+
+def get_layer_activities(code_text):
+    """Show layer activity statistics."""
+    net.context = np.zeros_like(net.context)
+    tokens = tok.encode(code_text, max_len=16)
+    embeddings = tok.embed_seq(tokens)
+    net.process_seq(embeddings, train=False)
+    
+    l1_acts = net.l1.activities
+    l2_acts = net.l2.activities
+    l3_acts = net.l3.activities
+    
+    output = "**Layer Activities (sample of active neurons):**\n\n"
+    
+    output += f"L1 (Sensory, {len(l1_acts)} neurons):\n"
+    active_l1 = np.where(l1_acts > 0.01)[0]
+    output += f"  Active: {len(active_l1)} ({len(active_l1)/len(l1_acts):.1%})\n"
+    output += f"  Top 5: {l1_acts[np.argsort(l1_acts)[-5:]][::-1].round(4).tolist()}\n\n"
+    
+    output += f"L2 (Hidden, {len(l2_acts)} neurons):\n"
+    active_l2 = np.where(l2_acts > 0.01)[0]
+    output += f"  Active: {len(active_l2)} ({len(active_l2)/len(l2_acts):.1%})\n"
+    output += f"  Top 5: {l2_acts[np.argsort(l2_acts)[-5:]][::-1].round(4).tolist()}\n\n"
+    
+    output += f"L3 (Context, {len(l3_acts)} neurons):\n"
+    active_l3 = np.where(l3_acts > 0.01)[0]
+    output += f"  Active: {len(active_l3)} ({len(active_l3)/len(l3_acts):.1%})\n"
+    output += f"  Top 5: {l3_acts[np.argsort(l3_acts)[-5:]][::-1].round(4).tolist()}\n"
+    
+    return output
+
+
+description = """
+# 🧠 Brain-like Predictive Coding Code World Model
+
+This model uses a **hierarchical predictive coding network** inspired by the brain's cortical hierarchy:
+- **L1 (Sensory)**: Processes code token embeddings like primary visual cortex
+- **L2 (Hidden)**: Learns associative patterns like inferotemporal cortex
+- **L3 (Context)**: Maintains sequence context like prefrontal cortex
+
+**Brain-like features:**
+- LIF (Leaky Integrate-and-Fire) neurons
+- PES (Prescribed Error Sensitivity) learning — error-driven weight updates
+- Top-down predictions from higher layers
+- Prediction errors drive learning (free-energy principle)
+- Numba JIT acceleration for fast CPU inference
+"""
+
+with gr.Blocks(title="Brain-like PC Code Model") as demo:
+    gr.Markdown(description)
+    
+    with gr.Tab("Code Prediction"):
+        with gr.Row():
+            with gr.Column():
+                code_input = gr.Textbox(
+                    label="Input Code",
+                    placeholder="def compute(x):\n  return",
+                    lines=3
+                )
+                n_steps = gr.Slider(1, 10, value=5, step=1, label="Prediction Steps")
+                predict_btn = gr.Button("Predict Next Tokens")
+            
+            with gr.Column():
+                output = gr.Markdown(label="Predictions")
+        
+        predict_btn.click(predict_code, inputs=[code_input, n_steps], outputs=output)
+    
+    with gr.Tab("Layer Activities"):
+        with gr.Row():
+            with gr.Column():
+                code_input2 = gr.Textbox(
+                    label="Input Code",
+                    placeholder="for i in range(10):",
+                    lines=2
+                )
+                act_btn = gr.Button("Show Activities")
+            
+            with gr.Column():
+                act_output = gr.Markdown(label="Layer Activities")
+        
+        act_btn.click(get_layer_activities, inputs=code_input2, outputs=act_output)
+
+if __name__ == "__main__":
+    demo.launch()