Create app.py

app.py

@@ -0,0 +1,430 @@
+import gradio as gr
+import numpy as np
+import time
+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
+    m_root_t = m_root_t.to(torch.float32)
+    A_t = A_t.to(torch.float32)
+    Q_t = Q_t.to(torch.float32)
+    alpha_t = alpha_t.to(torch.float32)
+    gamma_t = gamma_t.to(torch.float32)
+    omega_t = omega_t.to(torch.float32)
+
+    # Expand params
+    alpha_exp = alpha_t.unsqueeze(0)  # (1, Nmode)
+    gamma_exp = gamma_t.unsqueeze(0)
+    omega_exp = omega_t.unsqueeze(0)
+    m_root_exp = m_root_t.unsqueeze(1)  # (Ncells, 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
+
+    if torch.any(shred_mask):
+        eta_values = torch.zeros_like(Xi_norm)
+        eta_calc = 1.0 - torch.exp(-k_shred_global * (Xi_norm[shred_mask] - theta_global))
+        eta_values[shred_mask] = torch.clamp(eta_calc, 0.0, 1.0)
+
+        diss = 0.01 * m_root_t * eta_values
+        m_post = (1.0 - eta_values) * m_root_t - diss
+        m_post = torch.clamp(m_post, min=0.0)
+
+        m_root_t[shred_mask] = m_post[shred_mask]
+
+        shred_count = int(torch.sum(shred_mask).item())
+        if event_counts_t is not None:
+            if isinstance(event_counts_t, torch.Tensor):
+                if event_counts_t.dtype not in (torch.int64, torch.int32):
+                    event_counts_t = event_counts_t.to(torch.int64)
+                event_counts_t.add_(shred_count)
+            else:
+                event_counts_t += shred_count
+
+    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
+        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
+        )
+
+# --- 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):
+        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.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
+        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)
+        m_root_new = torch.clamp(m_root_new, min=0.0)
+        return m_root_new, A_modes_new, Q_drive
+
+    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
+            m_np = self.m_root.detach().cpu().numpy()
+            collapsed_mask = m_np <= 1e-8  # near-zero threshold to mark onset
+            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)
+    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
+    )
+
+    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
+        '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
+):
+    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
+        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
+        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()
+
+        # 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()
+
+        # 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.grid(True)
+
+        plt.tight_layout()
+        _, plot_path = tempfile.mkstemp(suffix=".png")
+        plt.savefig(plot_path)
+        plt.close(fig)
+
+        summary_output = (
+            f"Simulation completed in {results['elapsed_time_seconds']:.2f} seconds.\n\n"
+            f"Estimated GFLOPS: {results['gflops']:.2f}\n"
+            f"Final Mean m_root: {np.mean(results['final_m_root']):.6f}\n"
+            f"Final Mean A_modes: {np.mean(results['final_A_modes']):.6f}\n"
+            f"Total Events (last iteration): {results['event_counts_history'][-1] if len(results['event_counts_history']) > 0 else 0}\n\n"
+            f"-- Historical Data (first 5 values) --\n"
+            f"Mean m_root history: {results['m_root_history'][:5].tolist()}\n"
+            f"Mean A_modes history: {results['A_modes_history'][:5].tolist()}\n"
+            f"Event counts history: {results['event_counts_history'][:5].tolist()}"
+        )
+    except Exception as e:
+        summary_output = f"Error during RFT simulation: {e}"
+        plot_path = None
+
+    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.
+
+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.
+
+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.
+
+The shredding onset plot shows when each cell first collapses, making cascades visible in time.
+'''
+
+# --- Gradio UI ---
+with gr.Blocks(title="Render Frame Theory (RFT) Simulation Interface (CPU-ready)") as iface:
+    gr.Markdown(what_is_this_markdown)
+
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("### Simulation Parameters")
+            Ncells_slider = gr.Slider(minimum=16, maximum=512, step=16, value=64, label="⚡ Number of Cells (Ncells)")
+            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.**")
+            run_button = gr.Button("Run Simulation")
+
+        with gr.Column():
+            gr.Markdown("### Simulation Results")
+            summary_output_textbox = gr.Textbox(label="Simulation Summary", lines=15)
+            plot_output_image = gr.Image(label="Simulation Plots", type="filepath")
+
+    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
+        ],
+        outputs=[summary_output_textbox, plot_output_image]
+    )
+
+if __name__ == "__main__":
+    iface.launch(share=True)