Delete app.py

app.py

@@ -1,272 +0,0 @@
-import gradio as gr
-import numpy as np
-import time
-import torch
-import matplotlib.pyplot as plt
-import tempfile
-
-# Conditional import of cupy
-try:
-    import cupy as cp
-    _has_cupy = True
-except ImportError:
-    _has_cupy = False
-    print("CuPy not found. Running in CPU-only mode. Performance will be significantly lower.")
-
-# --- CUDA kernel source (kept for GPU path) ---
-cuda_source = r''' ... '''  # (unchanged, omitted for brevity)
-
-# --- 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)
-    alpha_t = alpha_t.to(torch.float32)
-    gamma_t = gamma_t.to(torch.float32)
-    omega_t = omega_t.to(torch.float32)
-
-    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)
-
-    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
-
-    A_t.add_(dt * A_dot)
-    Q_t.add_(dt * Q_dot)
-
-    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)
-        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 ---
-class MOMKernel:
-    def __init__(self, cuda_source, kernel_name='fused_mom_update', block_dim=128):
-        self.use_cuda = torch.cuda.is_available() and _has_cupy
-        if self.use_cuda:
-            try:
-                self.module = cp.RawModule(code=cuda_source, backend='nvcc', options=('-std=c++11',))
-                self.kernel = self.module.get_function(kernel_name)
-                self.device = torch.device('cuda')
-            except Exception:
-                self.use_cuda = False
-                self.kernel = fused_mom_update_cpu
-                self.device = torch.device('cpu')
-        else:
-            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):
-        if not self.use_cuda:
-            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)
-        return m_root_t, A_t, Q_t, event_counts_t
-
-# --- Feedback system ---
-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
-        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)
-        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
-        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)
-        self.m_root_history = []; self.A_modes_history = []; self.event_counts_history = []
-        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 shred onset
-            shredded = (self.m_root.cpu().numpy() == 0.0)
-            for idx, flag in enumerate(shredded):
-                if flag and self.shred_onset[idx] == -1:
-                    self.shred_onset[idx] = i
-            self.m_root, self.A_modes, self.Q_drive = self.feedback(self.m_root, self.A_modes, self.Q_drive)
-            self.m_root_history.append(self.m_root.mean().item())
-            self.A_modes_history.append(self.A_modes.mean().item())
-            self.event_counts_history.append(int(self.event_counts.item()))
-
-# --- Simulation wrapper ---
-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(cuda_source)
-    device = mom_kernel_instance.device
-    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)
-    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.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),
-    }
-
-
-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
-        )
-
-        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
-        ax4 = fig.add_subplot(4, 1, 4)
-        onset = results['shred_onset']
-        for idx, val in enumerate(onset):
-            if val >= 0:
-                ax4.vlines(val, idx, idx+1, color='black')
-        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]}\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
-
-
-# --- Gradio UI ---
-what_is_this_markdown = '''
-### Render Frame Theory (RFT)
-... (unchanged explanatory text) ...
-'''
-
-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(16, 512, step=16, value=64, label="⚡ Number of Cells (Ncells)")
-            Nmode_slider = gr.Slider(2, 32, step=2, value=8, label="🔮 Number of Modes (Nmode)")
-            iterations_slider = gr.Slider(10, 200, step=10, value=50, label="♾ Iterations")
-            dt_slider = gr.Slider(0.001, 0.1, step=0.001, value=0.02, label="⌛ Time Step (dt)")
-            eps_slider = gr.Slider(1e-7, 1e-4, step=1e-7, value=1e-6, label="🧿 Epsilon (eps)")
-            sigma_slider = gr.Slider(0.1, 1.0, step=0.05, value=0.75, label="🌌 Sigma (coupling strength)")
-            theta_slider = gr.Slider(0.1, 5.0, step=0.1, value=2.2, label="🔭 Theta (Shredding Threshold)")
-            k_shred_slider = gr.Slider(0.1, 5.0, step=0.1, value=1.2, label="🌀 K_shred (Shredding Rate)")
-            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)