Update app.py

app.py

@@ -75,32 +75,36 @@ def visualize_multi_grid_vram(memory_grids):
     
     return fig  # Return the whole figure object
 
-# Generate Spike Train using LIF Neurons
+# Generate Spike Train using LIF Neurons (Dynamic to Pressure)
 def generate_lif_spike_train(length=50, input_current=0.5):
     lif_neuron = LIFNeuron()
-    spike_train = [lif_neuron.step(input_current) for _ in range(length)]
-    return spike_train
+    spike_train = []
+    membrane_potentials = []
+    for t in range(length):
+        spike = lif_neuron.step(input_current)
+        spike_train.append(spike)
+        membrane_potentials.append(lif_neuron.v)
+    return spike_train, membrane_potentials
 
 # Visualize LIF Spike Train (Real-Time Update)
-def visualize_lif_spike_train(spike_train):
-    fig, ax = plt.subplots(figsize=(6, 4))
-    ax.plot(spike_train, marker='o', linestyle='-', color='b', markersize=5)
-    ax.set_title("LIF Neuron Spike Train")
-    ax.set_xlabel("Time Steps")
-    ax.set_ylabel("Spike Event (1 = Spike, 0 = No Spike)")
-    ax.set_yticks([0, 1])
-    ax.grid(True)
-    return fig  # Return the whole figure object
+def visualize_lif_spike_train(spike_train, membrane_potentials):
+    fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(6, 8))
+
+    # Plot Spike Train
+    ax1.plot(spike_train, marker='o', linestyle='-', color='b', markersize=5)
+    ax1.set_title("LIF Neuron Spike Train")
+    ax1.set_xlabel("Time Steps")
+    ax1.set_ylabel("Spike Event (1 = Spike, 0 = No Spike)")
+    ax1.set_yticks([0, 1])
+    ax1.grid(True)
+
+    # Plot Membrane Potentials
+    ax2.plot(membrane_potentials, color='r', marker='x', linestyle='-', markersize=5)
+    ax2.set_title("Membrane Potential Over Time")
+    ax2.set_xlabel("Time Steps")
+    ax2.set_ylabel("Membrane Potential (mV)")
+    ax2.grid(True)
 
-# New: Visualizing Synapse Learning with Action Potentials (Real-Time Update)
-def visualize_synapse_learning(spike_train):
-    membrane_potential = np.cumsum(spike_train)  # Simulating action potentials
-    fig, ax = plt.subplots(figsize=(6, 4))
-    ax.plot(membrane_potential, color='r', marker='x', linestyle='-', markersize=5)
-    ax.set_title("Synaptic Learning - Action Potential Over Time")
-    ax.set_xlabel("Time Steps")
-    ax.set_ylabel("Membrane Potential")
-    ax.grid(True)
     return fig  # Return the whole figure object
 
 # Generate Multi-Grid Spikes and VRAM Updates
@@ -111,14 +115,14 @@ def generate_spikes_for_pressure(pressure, grid_count=3):
     model = load_model(grid_count=grid_count)
     if model is not None:
         outputs, memory_grids = model(pressure_input)
-        spike_train = generate_lif_spike_train(length=50, input_current=pressure_normalized)
-        return outputs, memory_grids, spike_train
-    return None, None, None
+        spike_train, membrane_potentials = generate_lif_spike_train(length=50, input_current=pressure_normalized)
+        return outputs, memory_grids, spike_train, membrane_potentials
+    return None, None, None, None
 
 # Streamlit UI for Real-time Visualization
 def app():
     st.title("Neuromorphic Multi-Grid VRAM & LIF Spiking Network")
-    st.write("Observe multiple VRAM grids, LIF spikes, and synaptic learning in real time.")
+    st.write("Observe how pressure input affects the VRAM grids, LIF spikes, and membrane potential in real-time.")
 
     pressure = st.slider("Select Pressure (MPa)", 0.1, 1.0, 0.5, 0.1)
     grid_count = st.slider("Number of VRAM Grids", 1, 5, 3)
@@ -130,25 +134,21 @@ def app():
         # Create empty containers for real-time plotting
         plot_vram = st.empty()
         plot_spike_train = st.empty()
-        plot_synapse = st.empty()
 
-        # Layout: VRAM plots on top, Spike and Synaptic Learning below
+        # Layout: VRAM plots on top, Spike and Membrane Potentials below
         st.write("### VRAM Grids (Above)")
-        st.write("### LIF Spike Train & Synaptic Learning (Below)")
+        st.write("### LIF Spike Train & Membrane Potential (Below)")
 
         end_time = time.time() + duration * 60
         while time.time() < end_time:
-            outputs, memory_grids, spike_train = generate_spikes_for_pressure(pressure, grid_count)
+            outputs, memory_grids, spike_train, membrane_potentials = generate_spikes_for_pressure(pressure, grid_count)
 
             if outputs is not None and memory_grids is not None:
                 # Update VRAM plots dynamically
                 plot_vram.pyplot(visualize_multi_grid_vram(memory_grids))
 
-                # Update Spike Train plot
-                plot_spike_train.pyplot(visualize_lif_spike_train(spike_train))
-
-                # Update Synapse Learning plot
-                plot_synapse.pyplot(visualize_synapse_learning(spike_train))
+                # Update Spike Train and Membrane Potential plot
+                plot_spike_train.pyplot(visualize_lif_spike_train(spike_train, membrane_potentials))
 
             time.sleep(0.2)  # Update every 0.2 seconds