Update app.py

app.py

@@ -5,76 +5,10 @@ import torch
 import matplotlib.pyplot as plt
 import tempfile
 
-# Conditional import of cupy (GPU optional; this app runs CPU-only by default)
-try:
-    import cupy as cp
-    _has_cupy = True
-except ImportError:
-    _has_cupy = False
-    print("CuPy not found. Running in CPU-only mode.")
-
-# --- CUDA kernel source (kept for future GPU support; not used in CPU path) ---
-cuda_source = r'''
-extern "C" {
-__global__ void fused_mom_update(
-    const int Ncells,
-    const int Nmode,
-    const float dt,
-    const float eps,
-    const float sigma_const,
-    const float theta_global,
-    const float k_shred_global,
-    const float * __restrict__ d_alpha,
-    const float * __restrict__ d_gamma,
-    const float * __restrict__ d_omega,
-    float * __restrict__ d_mroot,
-    float * __restrict__ d_A,
-    float * __restrict__ d_Q,
-    unsigned int * __restrict__ d_event_counts,
-    unsigned long long * __restrict__ d_event_buffer
-) {
-    int cell_idx = blockIdx.x * blockDim.x + threadIdx.x;
-    if (cell_idx >= Ncells) return;
-    int base = cell_idx * Nmode;
-    float m = d_mroot[cell_idx];
-    float Xi = 0.0f;
-    for (int n = 0; n < Nmode; ++n) {
-        float A = d_A[base + n];
-        float Q = d_Q[base + n];
-        float A_dot = d_alpha[n] * m - d_gamma[n] * A + sigma_const * Q;
-        float f_drive = sigma_const * m * d_omega[n] * A;
-        float Q_dot = f_drive - Q;
-        A += dt * A_dot;
-        Q += dt * Q_dot;
-        d_A[base + n] = A;
-        d_Q[base + n] = Q;
-        Xi += d_omega[n] * A;
-    }
-    float Xi_norm = Xi / (m + eps);
-    if (Xi_norm >= theta_global) {
-        float eta = 1.0f - expf(-k_shred_global * (Xi_norm - theta_global));
-        if (eta < 0.0f) eta = 0.0f;
-        if (eta > 1.0f) eta = 1.0f;
-        float diss = 0.01f * m * eta;
-        float m_post = (1.0f - eta) * m - diss;
-        if (m_post < 0.0f) m_post = 0.0f;
-        d_mroot[cell_idx] = m_post;
-        unsigned int idx = atomicAdd(d_event_counts, 1u);
-        // Event buffer not used in this example
-    } else {
-        d_mroot[cell_idx] = m;
-    }
-}
-} // extern "C"
-'''
-
-# --- CPU kernel ---
-def fused_mom_update_cpu(
-    m_root_t, A_t, Q_t, alpha_t, gamma_t, omega_t,
-    dt, eps, sigma_const, theta_global, k_shred_global,
-    event_counts_t=None, event_buffer_t=None
-):
-    # Ensure float32
+# CPU kernel
+def fused_mom_update_cpu(m_root_t, A_t, Q_t, alpha_t, gamma_t, omega_t,
+                         dt, eps, sigma_const, theta_global, k_shred_global,
+                         event_counts_t=None, event_buffer_t=None):
     m_root_t = m_root_t.to(torch.float32)
     A_t = A_t.to(torch.float32)
     Q_t = Q_t.to(torch.float32)
@@ -82,25 +16,21 @@ def fused_mom_update_cpu(
     gamma_t = gamma_t.to(torch.float32)
     omega_t = omega_t.to(torch.float32)
 
-    # Expand params
-    alpha_exp = alpha_t.unsqueeze(0)  # (1, Nmode)
+    alpha_exp = alpha_t.unsqueeze(0)
     gamma_exp = gamma_t.unsqueeze(0)
     omega_exp = omega_t.unsqueeze(0)
-    m_root_exp = m_root_t.unsqueeze(1)  # (Ncells, 1)
+    m_root_exp = m_root_t.unsqueeze(1)
 
-    # Dynamics
     A_dot = alpha_exp * m_root_exp - gamma_exp * A_t + sigma_const * Q_t
     f_drive = sigma_const * m_root_exp * omega_exp * A_t
     Q_dot = f_drive - Q_t
 
-    # Euler update
     A_t.add_(dt * A_dot)
     Q_t.add_(dt * Q_dot)
 
-    # Shredding
-    Xi = (omega_exp * A_t).sum(dim=1)            # (Ncells)
-    Xi_norm = Xi / (m_root_t + eps)              # (Ncells)
-    shred_mask = Xi_norm >= theta_global         # bool mask
+    Xi = (omega_exp * A_t).sum(dim=1)
+    Xi_norm = Xi / (m_root_t + eps)
+    shred_mask = Xi_norm >= theta_global
 
     if torch.any(shred_mask):
         eta_values = torch.zeros_like(Xi_norm)
@@ -124,63 +54,41 @@ def fused_mom_update_cpu(
 
     return m_root_t, A_t, Q_t, event_counts_t
 
-# --- Kernel wrapper (CPU-first) ---
 class MOMKernel:
-    def __init__(self, cuda_source, kernel_name='fused_mom_update', block_dim=128):
-        # CPU path by default; GPU path omitted for simplicity
-        self.use_cuda = False
+    def __init__(self):
         self.kernel = fused_mom_update_cpu
         self.device = torch.device('cpu')
 
-    def __call__(
-        self, m_root_t, A_t, Q_t, alpha_t, gamma_t, omega_t,
-        dt, eps, sigma_const, theta_global, k_shred_global,
-        event_counts_t=None, event_buffer_t=None
-    ):
-        return self.kernel(
-            m_root_t, A_t, Q_t, alpha_t, gamma_t, omega_t,
-            dt, eps, sigma_const, theta_global, k_shred_global,
-            event_counts_t, event_buffer_t
-        )
+    def __call__(self, m_root_t, A_t, Q_t, alpha_t, gamma_t, omega_t,
+                 dt, eps, sigma_const, theta_global, k_shred_global,
+                 event_counts_t=None, event_buffer_t=None):
+        return self.kernel(m_root_t, A_t, Q_t, alpha_t, gamma_t, omega_t,
+                           dt, eps, sigma_const, theta_global, k_shred_global,
+                           event_counts_t, event_buffer_t)
 
-# --- System loop with feedback and onset tracking ---
 class MOMSystemLoop:
     def __init__(self, mom_kernel, m_root_initial, A_modes_initial, Q_drive_initial,
-                 alpha, gamma, omega,
-                 dt=0.02, eps=1e-6, sigma=0.75,
-                 theta=2.2, k_shred=1.2,
-                 event_buffer_size=1024):
+                 alpha, gamma, omega, dt=0.02, eps=1e-6, sigma=0.75,
+                 theta=2.2, k_shred=1.2, event_buffer_size=1024):
         self.mom_kernel = mom_kernel
         self.device = mom_kernel.device
-
-        # State
-        self.m_root  = m_root_initial.to(self.device).clone().to(torch.float32)
+        self.m_root = m_root_initial.to(self.device).clone().to(torch.float32)
         self.A_modes = A_modes_initial.to(self.device).clone().to(torch.float32)
         self.Q_drive = Q_drive_initial.to(self.device).clone().to(torch.float32)
-
-        # Params
         self.alpha = alpha.to(self.device).to(torch.float32)
         self.gamma = gamma.to(self.device).to(torch.float32)
         self.omega = omega.to(self.device).to(torch.float32)
-
         self.dt = dt; self.eps = eps; self.sigma = sigma
         self.theta = theta; self.k_shred = k_shred
-
-        # Event tracking
         self.event_counts = torch.zeros((), dtype=torch.int64, device=self.device)
         self.event_buffer = torch.zeros(event_buffer_size, dtype=torch.int64, device=self.device)
-
-        # Histories
         self.m_root_history = []
         self.A_modes_history = []
         self.event_counts_history = []
-
-        # Shredding onset (per-cell first time reaching near-zero mass)
         self.shred_onset = np.full((self.m_root.shape[0],), -1, dtype=np.int32)
 
     def feedback(self, m_root, A_modes, Q_drive):
-        decay = 0.995
-        noise_level = 1e-4
+        decay = 0.995; noise_level = 1e-4
         A_modes_new = A_modes * decay + noise_level * torch.randn_like(A_modes, device=self.device)
         A_modes_new = torch.clamp(A_modes_new, min=0.0)
         m_root_new = m_root * decay + noise_level * torch.randn_like(m_root, device=self.device)
@@ -190,150 +98,83 @@ class MOMSystemLoop:
     def run(self, iterations):
         for i in range(iterations):
             self.event_counts.zero_()
-
-            self.mom_kernel(
-                self.m_root, self.A_modes, self.Q_drive,
-                self.alpha, self.gamma, self.omega,
-                self.dt, self.eps, self.sigma, self.theta, self.k_shred,
-                self.event_counts, self.event_buffer
-            )
-
-            # Record shredding onset if mass is effectively collapsed
+            self.mom_kernel(self.m_root, self.A_modes, self.Q_drive,
+                            self.alpha, self.gamma, self.omega,
+                            self.dt, self.eps, self.sigma, self.theta, self.k_shred,
+                            self.event_counts, self.event_buffer)
             m_np = self.m_root.detach().cpu().numpy()
-            collapsed_mask = m_np <= 1e-8  # near-zero threshold to mark onset
+            collapsed_mask = m_np <= 1e-8
             for idx, collapsed in enumerate(collapsed_mask):
                 if collapsed and self.shred_onset[idx] == -1:
                     self.shred_onset[idx] = i
-
-            # Feedback after kernel update
             self.m_root, self.A_modes, self.Q_drive = self.feedback(self.m_root, self.A_modes, self.Q_drive)
-
-            # Histories
             self.m_root_history.append(float(self.m_root.mean().item()))
             self.A_modes_history.append(float(self.A_modes.mean().item()))
             self.event_counts_history.append(int(self.event_counts.item()))
 
-# --- Simulation wrapper ---
-def run_rft_simulation(
-    Ncells: int,
-    Nmode: int,
-    iterations: int,
-    dt: float = 0.02,
-    eps: float = 1e-6,
-    sigma: float = 0.75,
-    theta: float = 2.2,
-    k_shred: float = 1.2,
-    seed: int = 42
-):
-    torch.manual_seed(seed)
-    np.random.seed(seed)
-
-    # Kernel and device
-    mom_kernel_instance = MOMKernel(cuda_source, kernel_name='fused_mom_update', block_dim=128)
+def run_rft_simulation(Ncells, Nmode, iterations, dt=0.02, eps=1e-6, sigma=0.75,
+                       theta=2.2, k_shred=1.2, seed=42):
+    torch.manual_seed(seed); np.random.seed(seed)
+    mom_kernel_instance = MOMKernel()
     device = mom_kernel_instance.device
-
-    # Parameters on device
-    alpha = torch.empty(Nmode, device=device, dtype=torch.float32).uniform_(0.02, 0.12)
-    gamma = torch.empty(Nmode, device=device, dtype=torch.float32).uniform_(0.01, 0.06)
-    omega = torch.linspace(1.0, 8.0, Nmode, device=device, dtype=torch.float32)
-
-    # Initial states
-    m_root_initial = torch.ones(Ncells, device=device, dtype=torch.float32)
-    A_modes_initial = torch.rand(Ncells, Nmode, device=device, dtype=torch.float32) * 0.01
-    Q_drive_initial = torch.zeros(Ncells, Nmode, device=device, dtype=torch.float32)
-
-    mom_system = MOMSystemLoop(
-        mom_kernel_instance, m_root_initial, A_modes_initial, Q_drive_initial,
-        alpha, gamma, omega,
-        dt=dt, eps=eps, sigma=sigma, theta=theta, k_shred=k_shred
-    )
-
+    alpha = torch.empty(Nmode, device=device).uniform_(0.02, 0.12)
+    gamma = torch.empty(Nmode, device=device).uniform_(0.01, 0.06)
+    omega = torch.linspace(1.0, 8.0, Nmode, device=device)
+    m_root_initial = torch.ones(Ncells, device=device)
+    A_modes_initial = torch.rand(Ncells, Nmode, device=device) * 0.01
+    Q_drive_initial = torch.zeros(Ncells, Nmode, device=device)
+    mom_system = MOMSystemLoop(mom_kernel_instance, m_root_initial, A_modes_initial, Q_drive_initial,
+                               alpha, gamma, omega, dt=dt, eps=eps, sigma=sigma,
+                               theta=theta, k_shred=k_shred)
     start_time = time.time()
     mom_system.run(iterations)
     elapsed_time = max(time.time() - start_time, 1e-9)
-
-    # GFLOPS estimate
     ops_per_cell_per_iter = 12 * Nmode + 13
     flops_per_iteration = float(Ncells) * float(ops_per_cell_per_iter)
     total_flops = flops_per_iteration * float(iterations)
     gflops = total_flops / (elapsed_time * 1e9)
-
     return {
-        'final_m_root': mom_system.m_root.detach().cpu().numpy().astype(np.float32),
-        'final_A_modes': mom_system.A_modes.detach().cpu().numpy().astype(np.float32),
-        'final_Q_drive': mom_system.Q_drive.detach().cpu().numpy().astype(np.float32),
-        'm_root_history': np.array(mom_system.m_root_history, dtype=np.float32),
-        'A_modes_history': np.array(mom_system.A_modes_history, dtype=np.float32),
-        'event_counts_history': np.array(mom_system.event_counts_history, dtype=np.int64),
-        'shred_onset': mom_system.shred_onset,  # per-cell first-onset iteration or -1
+        'final_m_root': mom_system.m_root.cpu().numpy(),
+        'final_A_modes': mom_system.A_modes.cpu().numpy(),
+        'final_Q_drive': mom_system.Q_drive.cpu().numpy(),
+        'm_root_history': np.array(mom_system.m_root_history),
+        'A_modes_history': np.array(mom_system.A_modes_history),
+        'event_counts_history': np.array(mom_system.event_counts_history),
+        'shred_onset': mom_system.shred_onset,
         'elapsed_time_seconds': float(elapsed_time),
         'gflops': float(gflops),
     }
 
-# --- Gradio callback ---
-def rft_simulation_interface(
-    Ncells: int,
-    Nmode: int,
-    iterations: int,
-    dt: float,
-    eps: float,
-    sigma: float,
-    theta: float,
-    k_shred: float
-):
+def rft_simulation_interface(Ncells, Nmode, iterations, dt, eps, sigma, theta, k_shred):
     try:
-        results = run_rft_simulation(
-            Ncells=Ncells,
-            Nmode=Nmode,
-            iterations=iterations,
-            dt=dt,
-            eps=eps,
-            sigma=sigma,
-            theta=theta,
-            k_shred=k_shred
-        )
-
-        # Create plots: 4 subplots including raster of shredding onset
+        results = run_rft_simulation(Ncells, Nmode, iterations, dt, eps, sigma, theta, k_shred)
         fig = plt.figure(figsize=(10, 14))
-
-        # Plot 1: Mean m_root
         ax1 = fig.add_subplot(4, 1, 1)
         ax1.plot(results['m_root_history'], label='Mean m_root')
-        ax1.set_title('Mean m_root Over Iterations')
-        ax1.set_xlabel('Iteration')
-        ax1.set_ylabel('Mean m_root')
-        ax1.grid(True)
-        ax1.legend()
-
-        # Plot 2: Mean A_modes
+        ax1.set_title('Mean m_root Over Iterations'); ax1.set_xlabel('Iteration'); ax1.set_ylabel('Mean m_root')
+        ax1.grid(True); ax1.legend()
         ax2 = fig.add_subplot(4, 1, 2)
         ax2.plot(results['A_modes_history'], label='Mean A_modes', color='orange')
         ax2.set_title('Mean A_modes Over Iterations')
-        ax2.set_xlabel('Iteration')
-        ax2.set_ylabel('Mean A_modes')
-        ax2.grid(True)
-        ax2.legend()
+        ax2.set_xlabel('Iteration'); ax2.set_ylabel('Mean A_modes')
+        ax2.grid(True); ax2.legend()
 
         # Plot 3: Cumulative Shredding Events
         ax3 = fig.add_subplot(4, 1, 3)
         cumulative_events = np.cumsum(results['event_counts_history'])
         ax3.plot(cumulative_events, label='Cumulative Shredding Events', color='red')
         ax3.set_title('Cumulative Shredding Events')
-        ax3.set_xlabel('Iteration')
-        ax3.set_ylabel('Cumulative Events')
-        ax3.grid(True)
-        ax3.legend()
+        ax3.set_xlabel('Iteration'); ax3.set_ylabel('Cumulative Events')
+        ax3.grid(True); ax3.legend()
 
         # Plot 4: Raster of shredding onset per cell
         ax4 = fig.add_subplot(4, 1, 4)
         onset = results['shred_onset']
-        # Draw a vertical tick at the onset iteration for each cell that shredded
         for idx, val in enumerate(onset):
             if val >= 0:
                 ax4.vlines(val, idx, idx + 1, color='black', linewidth=0.8)
         ax4.set_title('Shredding Onset per Cell')
-        ax4.set_xlabel('Iteration')
-        ax4.set_ylabel('Cell Index')
+        ax4.set_xlabel('Iteration'); ax4.set_ylabel('Cell Index')
         ax4.grid(True)
 
         plt.tight_layout()
@@ -358,28 +199,26 @@ def rft_simulation_interface(
 
     return summary_output, plot_path
 
-# --- Explanatory markdown ---
-what_is_this_markdown = '''
-### What is Render Frame Theory (RFT)?
-Render Frame Theory (RFT) is a computational framework for simulating complex adaptive systems with emergent, non-linear dynamics. It models a system as a collection of cells, each with internal modes that evolve over time through coupled updates and event-driven transitions.
+# --- Explanatory markdown embedded directly ---
+with gr.Blocks(title="Rendered Frame Theory (RFT) Simulation Interface") as iface:
+    gr.Markdown("""
+    ### What is Rendered Frame Theory (RFT)?
 
-Key features:
-- **Dynamic systems:** Evolves `m_root` (root mass), `A_modes` (mode amplitudes), and `Q_drive` (drive) over iterations.
-- **Feedback loops:** Each iteration adjusts states based on prior values, enabling adaptation.
-- **Emergent behavior:** A shredding mechanism triggers non-linear collapse when stress crosses a threshold.
-- **Performance scaling:** Designed to scale with the number of cells and modes, enabling large explorations.
+    Rendered Frame Theory (RFT) is a computational framework for simulating complex adaptive systems with emergent, non-linear dynamics. It models a system as a collection of cells, each with internal modes that evolve over time through coupled updates and event-driven transitions.
 
-Why it matters:
-- **Granularity:** Captures local interactions and cell-level transitions that averaged models miss.
-- **Critical events:** Models sudden cascades like market crashes, neural avalanches, or material failure.
-- **Versatility:** Applicable to finance, biology, engineering, and AI research.
+    **Key features:**
+    - ⚡ Dynamic systems: Evolves m_root (root mass), A_modes (mode amplitudes), and Q_drive (drive) over iterations.
+    - 🔄 Feedback loops: Each iteration adjusts states based on prior values, enabling adaptation.
+    - 🌀 Emergent behavior: A shredding mechanism triggers non-linear collapse when stress crosses a threshold.
+    - 📈 Performance scaling: Designed to scale with the number of cells and modes, enabling large explorations.
 
-The shredding onset plot shows when each cell first collapses, making cascades visible in time.
-'''
+    **Why it matters:**
+    - 🔬 Granularity: Captures local interactions and cell-level transitions that averaged models miss.
+    - ⚠️ Critical events: Models sudden cascades like market crashes, neural avalanches, or material failure.
+    - 🌍 Versatility: Applicable to finance, biology, engineering, and AI research.
 
-# --- Gradio UI ---
-with gr.Blocks(title="Render Frame Theory (RFT) Simulation Interface (CPU-ready)") as iface:
-    gr.Markdown(what_is_this_markdown)
+    The shredding onset plot shows when each cell first collapses, making cascades visible in time.
+    """)
 
     with gr.Row():
         with gr.Column():
@@ -388,28 +227,10 @@ with gr.Blocks(title="Render Frame Theory (RFT) Simulation Interface (CPU-ready)
             Nmode_slider = gr.Slider(minimum=2, maximum=32, step=2, value=8, label="🔮 Number of Modes (Nmode)")
             iterations_slider = gr.Slider(minimum=10, maximum=200, step=10, value=50, label="♾ Iterations")
             dt_slider = gr.Slider(minimum=0.001, maximum=0.1, step=0.001, value=0.02, label="⌛ Time Step (dt)")
-            eps_slider = gr.Slider(
-                minimum=1e-7, maximum=1e-4, step=1e-7, value=1e-6,
-                label="🧿 Epsilon (eps)",
-                info="Small constant to stabilize Xi_norm division."
-            )
-            sigma_slider = gr.Slider(
-                minimum=0.1, maximum=1.0, step=0.05, value=0.75,
-                label="🌌 Sigma (coupling strength)",
-                info="Strength of Q–A interaction; higher values intensify dynamics."
-            )
-            theta_slider = gr.Slider(
-                minimum=0.1, maximum=5.0, step=0.1, value=2.2,
-                label="🔭 Theta (Shredding Threshold)",
-                info="Stress threshold (Xi_norm) above which shredding begins."
-            )
-            k_shred_slider = gr.Slider(
-                minimum=0.1, maximum=5.0, step=0.1, value=1.2,
-                label="🌀 K_shred (Shredding Rate)",
-                info="Intensity of shredding once triggered."
-            )
-
-            gr.Markdown("**Adjust parameters and click below to start the simulation.**")
+            eps_slider = gr.Slider(minimum=1e-7, maximum=1e-4, step=1e-7, value=1e-6, label="🧿 Epsilon (eps)")
+            sigma_slider = gr.Slider(minimum=0.1, maximum=1.0, step=0.05, value=0.75, label="🌌 Sigma (coupling strength)")
+            theta_slider = gr.Slider(minimum=0.1, maximum=5.0, step=0.1, value=2.2, label="🔭 Theta (Shredding Threshold)")
+            k_shred_slider = gr.Slider(minimum=0.1, maximum=5.0, step=0.1, value=1.2, label="🌀 K_shred (Shredding Rate)")
             run_button = gr.Button("Run Simulation")
 
         with gr.Column():
@@ -419,10 +240,8 @@ with gr.Blocks(title="Render Frame Theory (RFT) Simulation Interface (CPU-ready)
 
     run_button.click(
         fn=rft_simulation_interface,
-        inputs=[
-            Ncells_slider, Nmode_slider, iterations_slider, dt_slider, eps_slider,
-            sigma_slider, theta_slider, k_shred_slider
-        ],
+        inputs=[Ncells_slider, Nmode_slider, iterations_slider, dt_slider, eps_slider,
+                sigma_slider, theta_slider, k_shred_slider],
         outputs=[summary_output_textbox, plot_output_image]
     )