Update app.py

app.py

@@ -1,140 +1,195 @@
 import gradio as gr
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
 import numpy as np
+import time
 
 # ==========================================
-# THE DNA (NEURAL PHYSICS ENGINE)
+# THE ARCHITECTURE (64-BIT RISC-V)
 # ==========================================
-class NeuralPhysics(nn.Module):
-    def __init__(self, channel_n=16):
-        super().__init__()
-        self.channel_n = channel_n
-        
-        # Input: 48 channels (16 channels * 3 filters)
-        # Output: 128 hidden features
-        self.w1 = nn.Conv2d(channel_n * 3, 128, 1, 1)
-        self.w2 = nn.Conv2d(128, channel_n, 1, 1)
-        
-        # Initialize weights with slightly higher variance so life explodes faster
-        with torch.no_grad():
-            self.w1.weight.normal_(0.0, 0.05) # Increased variance
-            self.w1.bias.normal_(0.0, 0.05)
-            self.w2.weight.zero_() # Output layer starts at 0 (stable)
-
-    def forward(self, x):
-        # 1. PERCEPTION
-        ident = torch.tensor([[0,0,0],[0,1,0],[0,0,0]]).float()
-        sobel_x = torch.tensor([[-1,0,1],[-2,0,2],[-1,0,1]]).float() / 8.0
-        sobel_y = torch.tensor([[-1,-2,-1],[0,0,0],[1,2,1]]).float() / 8.0
-        
-        kernel = torch.stack([ident, sobel_x, sobel_y]).unsqueeze(1)
-        filters = kernel.repeat(self.channel_n, 1, 1, 1).to(x.device)
-        
-        y = F.conv2d(x, filters, padding=1, groups=self.channel_n)
+class VisualRISCV:
+    def __init__(self):
+        # 64KB RAM (Small enough to visualize as a 256x256 image)
+        self.RAM_SIZE = 65536 
+        self.ram = np.zeros(self.RAM_SIZE, dtype=np.int64)
+        self.registers = np.zeros(32, dtype=np.int64)
+        self.pc = 0 
+        self.logs = []
+
+    def log(self, msg):
+        self.logs.append(msg)
+
+    def reset(self):
+        self.ram.fill(0)
+        self.registers.fill(0)
+        self.pc = 0
+        self.logs = []
+        self.log("⚡ SYSTEM RESET.")
+
+    def get_ram_image(self):
+        # Convert RAM (1D array) to 2D Image (256x256)
+        # We normalize values to be visible (0-255)
+        grid = self.ram.reshape((256, 256))
         
-        # 2. COGNITION
-        y = F.relu(self.w1(y))
-        y = self.w2(y)
+        # Make it look cool: Any non-zero value lights up
+        # We use a modulo to make math patterns look like gradients
+        visual_grid = (grid % 255).astype(np.uint8)
+        return visual_grid
+
+    def execute(self, steps=1000):
+        start = time.time()
+        for _ in range(steps):
+            if self.pc >= self.RAM_SIZE: break
+            
+            instr = self.ram[self.pc]
+            if instr == 0: break # End of code
+
+            # DECODE
+            opcode = instr & 0x7F
+            rd = (instr >> 7) & 0x1F
+            rs1 = (instr >> 15) & 0x1F
+            rs2 = (instr >> 20) & 0x1F
+            imm = (instr >> 20)
+
+            # EXECUTE
+            if opcode == 1: # ADDI
+                self.registers[rd] = self.registers[rs1] + imm
+            elif opcode == 2: # ADD
+                # Fix for register mapping
+                real_rs2 = (instr >> 20) & 0x1F
+                self.registers[rd] = self.registers[rs1] + self.registers[real_rs2]
+            elif opcode == 3: # STORE
+                addr = self.registers[rs1] + imm
+                if addr < self.RAM_SIZE:
+                    self.ram[int(addr)] = self.registers[rd]
+            elif opcode == 4: # JUMP (BNE)
+                if self.registers[rd] != 0:
+                    self.pc -= imm
+                    continue
+            elif opcode == 99: # HALT
+                break
+            
+            self.pc += 1
         
-        # 3. UPDATE
-        # Stochastic update (cells fire randomly)
-        stochastic = (torch.rand(x.shape[0], 1, x.shape[2], x.shape[3]) > 0.5).float().to(x.device)
-        return x + y * stochastic
+        return time.time() - start
 
 # ==========================================
-# THE LIVING GRID
+# THE PROGRAMS (SOFTWARE)
 # ==========================================
-class LivingCPU:
-    def __init__(self, size=64):
-        self.size = size
-        self.channels = 16
-        
-        # The Grid: [Batch, Channels, Height, Width]
-        self.grid = torch.zeros(1, self.channels, size, size)
-        
-        # FIX: Seed the VISIBLE channels (RGB) too, not just hidden ones
-        # Set the center 3x3 pixels to 1.0 (White Square)
-        mid = size // 2
-        self.grid[:, :, mid-1:mid+1, mid-1:mid+1] = 1.0
-        
-        self.model = NeuralPhysics(self.channels)
-        self.step_count = 0
-
-    def step(self, loops=20):
-        # Run multiple steps per call so the user sees changes
-        with torch.no_grad():
-            for _ in range(loops):
-                self.grid = self.model(self.grid)
-                self.grid.clamp_(0.0, 1.0)
-                self.step_count += 1
-        return self.render()
-
-    def damage(self):
-        # Destroy a random chunk
-        cx = np.random.randint(10, self.size-10)
-        cy = np.random.randint(10, self.size-10)
-        # Set all channels to 0 in that square
-        self.grid[:, :, cx:cx+16, cy:cy+16] = 0.0
-        return "⚠️ DAMAGE DETECTED! REGENERATING..."
-
-    def render(self):
-        # Take first 3 channels (RGB)
-        # [1, 3, H, W] -> [H, W, 3]
-        img_tensor = self.grid[0, :3, :, :].permute(1, 2, 0)
-        
-        # Scale to 0-255
-        img_np = (img_tensor.clamp(0, 1).numpy() * 255).astype(np.uint8)
-        return img_np
+
+# 1. FIBONACCI VISUALIZER
+# Calculates Fibonacci numbers and writes them to RAM sequentially.
+# This creates a "Static" noise pattern that represents pure math.
+fib_code = """[
+    # R1 = Address Pointer (Start at 256 to skip code area)
+    (256 << 20) | (0 << 15) | (1 << 7) | 1,
+
+    # R2 = Fib A (1)
+    (1 << 20) | (0 << 15) | (2 << 7) | 1,
+
+    # R3 = Fib B (1)
+    (1 << 20) | (0 << 15) | (3 << 7) | 1,
+
+    # R4 = Loop Counter (Run 10,000 times)
+    (10000 << 20) | (0 << 15) | (4 << 7) | 1,
+
+    # --- LOOP START ---
+    
+    # STORE Fib A (R2) to RAM[R1]
+    (0 << 20) | (1 << 15) | (2 << 7) | 3,
+
+    # CALC NEXT FIB: R5 = R2 + R3
+    (3 << 20) | (2 << 15) | (5 << 7) | 2,
+
+    # SHIFT: R2 = R3
+    (0 << 20) | (3 << 15) | (2 << 7) | 2, # Add 0 to move
+
+    # SHIFT: R3 = R5
+    (0 << 20) | (5 << 15) | (3 << 7) | 2,
+
+    # INCREMENT POINTER: R1++
+    (1 << 20) | (1 << 15) | (1 << 7) | 1,
+
+    # DECREMENT COUNTER: R4--
+    (-1 << 20) | (4 << 15) | (4 << 7) | 1,
+
+    # JUMP BACK 6 STEPS IF R4 != 0
+    (6 << 20) | (0 << 15) | (4 << 7) | 4,
+
+    # HALT
+    99
+]"""
+
+# 2. MEMORY FILLER (Gradient)
+# Fills RAM with a linear gradient.
+grad_code = """[
+    # R1 = Address (Start 256)
+    (256 << 20) | (0 << 15) | (1 << 7) | 1,
+    # R2 = Value (0)
+    (0 << 20) | (0 << 15) | (2 << 7) | 1,
+    # R3 = Counter (60000)
+    (60000 << 20) | (0 << 15) | (3 << 7) | 1,
+
+    # STORE RAM[R1] = R2
+    (0 << 20) | (1 << 15) | (2 << 7) | 3,
+    # R1++
+    (1 << 20) | (1 << 15) | (1 << 7) | 1,
+    # R2++
+    (1 << 20) | (2 << 15) | (2 << 7) | 1,
+    # R3--
+    (-1 << 20) | (3 << 15) | (3 << 7) | 1,
+    # JUMP BACK 4
+    (4 << 20) | (0 << 15) | (3 << 7) | 4,
+    99
+]"""
 
 # ==========================================
 # GRADIO APP
 # ==========================================
 
-cpu_life = LivingCPU()
-
-def step_fn():
-    # Run 50 generations per click
-    img = cpu_life.step(loops=50)
-    return img, f"Cycle: {cpu_life.step_count} | Status: Growing"
-
-def damage_fn():
-    msg = cpu_life.damage()
-    img = cpu_life.render()
-    return img, msg
+cpu = VisualRISCV()
 
-def reset_fn():
-    cpu_life.__init__()
-    img = cpu_life.render()
-    return img, "♻️ SYSTEM REBORN."
+def run_cpu(prog_name):
+    cpu.reset()
+    
+    # Select Program
+    if prog_name == "Fibonacci Math":
+        code = eval(fib_code)
+    else:
+        code = eval(grad_code)
+        
+    # Flash Code
+    for i, instr in enumerate(code):
+        cpu.ram[i] = int(instr)
+        
+    cpu.log(f"💾 LOADED {prog_name}")
+    
+    # Run
+    cpu.log("🚀 EXECUTING...")
+    # We run 60,000 cycles to ensure the image fills up
+    t = cpu.execute(steps=60000)
+    
+    img = cpu.get_ram_image()
+    
+    reg_str = f"R1 (Addr): {cpu.registers[1]}\nR2 (Val): {cpu.registers[2]}\nR3 (Val): {cpu.registers[3]}"
+    
+    return img, "\n".join(cpu.logs), reg_str
 
-with gr.Blocks() as demo:
-    gr.Markdown("# 🧬 The Self-Healing Neural CPU")
-    gr.Markdown("### Artificial Life Simulation")
+with gr.Blocks(theme=gr.themes.Monochrome()) as demo:
+    gr.Markdown("# 🧠 Visual RISC-V Core")
+    gr.Markdown("### Seeing the Math")
+    gr.Markdown("This system runs real calculations. The image below is not a picture; it is a **Direct View of the RAM**. Every pixel is a number calculated by the CPU.")
     
     with gr.Row():
         with gr.Column():
-            # Display the grid
-            screen = gr.Image(label="Living Logic Grid", height=400, image_mode="RGB", type="numpy")
-            status = gr.Textbox(label="System Status", value="Ready. Seed Planted.")
-        
-        with gr.Column():
-            step_btn = gr.Button("🧬 Evolve (Fast Forward)", variant="primary")
-            damage_btn = gr.Button("💥 Inflict Damage", variant="stop")
-            reset_btn = gr.Button("♻️ Rebirth")
+            prog_select = gr.Radio(["Fibonacci Math", "Linear Gradient"], label="Select Program", value="Fibonacci Math")
+            run_btn = gr.Button("Run Calculation", variant="primary")
+            logs = gr.Textbox(label="System Logs")
+            regs = gr.Textbox(label="CPU Registers")
             
-            gr.Markdown("""
-            **Instructions:**
-            1. Click **Evolve**. You will see the white seed explode into colors.
-            2. Keep clicking **Evolve** to watch the pattern stabilize.
-            3. Click **Inflict Damage** to delete a chunk.
-            4. Click **Evolve** again to watch it heal.
-            """)
-
-    step_btn.click(step_fn, outputs=[screen, status])
-    damage_btn.click(damage_fn, outputs=[screen, status])
-    reset_btn.click(reset_fn, outputs=[screen, status])
+        with gr.Column():
+            # Visualizing RAM
+            ram_view = gr.Image(label="RAM Visualization (256x256)", height=400, image_mode="L", type="numpy")
+
+    run_btn.click(run_cpu, inputs=prog_select, outputs=[ram_view, logs, regs])
 
 if __name__ == "__main__":
-    demo.launch(theme=gr.themes.Glass())
+    demo.launch()