Update app.py

app.py

@@ -5,55 +5,251 @@ import matplotlib.pyplot as plt
 import gradio as gr
 import pandas as pd
 
+# --- Your Helper Functions ---
 
 def flatten(img : np.array) -> list[int] :
+    """Converts a 2D numpy array into a 1D list."""
     new : list[int] = []
     for row in img:
         for item in row:
             new.append(int(item))
     return new
 
+def sgn(x):
+    """Sign function."""
+    if x < 0:
+        return -1
+    if x == 0:
+        return 0
+    return 1
+
+# --- Your Hopfield Class (with one bugfix) ---
+
 class Hopfield:
     def __init__(self,patts):
         self.E : list[int] = []
         self.patts = patts
-        self.size = (4,4) 
+        self.size = (4,4) # Fixed size for reshaping
         self.Px :int = len(patts)
         self.Py :int = len(patts[0])
-        
+        # Initialize weights
         self.W : np.array = np.zeros((self.Py,self.Py),dtype=np.float16)
     
     def train(self):
-        
+        """Trains the network on the patterns provided in __init__."""
         for i in range(self.Py):
             for j in range(self.Py):
                 if i == j:
                     self.W[i][j] = 0
                     continue
-                
+                # Hebbian rule
                 self.W[i][j] = (1 / self.Px) * sum([patt[i] * patt[j] for patt in self.patts])
     
     def Energy(self):
-        
+        """Returns the list of energy values recorded during updates."""
         return self.E
     
     def update(self,pattern):
-        
+        """
+        Performs one asynchronous update step on the entire pattern.
+        """
+        # Flatten the 2D input pattern to 1D
         pattern_flat = flatten(pattern)
         
-        
+        # Calculate the new state vector H
         H : list[int] = []
         for i in self.W:
-            
-            H.append((sum([w * s for w,s in zip(i, pattern_flat)])))
+            # H_i = sgn(sum(W_ij * S_j))
+            H.append(sgn(sum([w * s for w,s in zip(i, pattern_flat)])))
         
         H = np.array(H)
-        H = np.sign(H)
         
+        # Calculate the energy of this new state H
         E = 0
         for i in range(self.Py):
             for j in range(self.Py):
                 E += float(-0.5 * self.W[i][j] * H[i] * H[j])
         self.E.append(E)
         
-        
+        # --- FIX ---
+        # Use reshape, not resize. Resize can add/remove elements.
+        # Reshape will fail if H doesn't have 16 elements, which is safer.
+        return H.reshape(self.size)
+
+# --- Default Patterns for the Gradio App ---
+
+# Pattern 1: 'X'
+patt_1_default = [[ 1, -1, -1,  1],
+                  [-1,  1,  1, -1],
+                  [-1,  1,  1, -1],
+                  [ 1, -1, -1,  1]]
+
+# Pattern 2: 'C'
+patt_2_default = [[ 1,  1,  1, -1],
+                  [ 1, -1, -1, -1],
+                  [ 1, -1, -1, -1],
+                  [ 1,  1,  1, -1]]
+
+# Pattern 3: 'L'
+patt_3_default = [[ 1, -1, -1, -1],
+                  [ 1, -1, -1, -1],
+                  [ 1, -1, -1, -1],
+                  [ 1,  1,  1,  1]]
+
+# Initial (corrupted) shape to test
+initial_shape_default = [[ 1,  1, -1, -1],
+                         [ 1, -1, -1, -1],
+                         [ 1, -1,  1, -1],
+                         [ 1,  1,  1, -1]]
+
+# --- Gradio Core Logic ---
+
+def clean_dataframe(df):
+    """Helper to convert Gradio dataframe to a clean NumPy array."""
+    # Fill any empty cells (None) with -1 and convert to int
+    return df.fillna(-1).to_numpy(dtype=int)
+
+def run_hopfield(patt1_df, patt2_df, patt3_df, initial_shape_df, steps):
+    """
+    The main function for the Gradio interface.
+    """
+    
+    # 1. Clean inputs
+    p1 = clean_dataframe(patt1_df)
+    p2 = clean_dataframe(patt2_df)
+    p3 = clean_dataframe(patt3_df)
+    initial_shape = clean_dataframe(initial_shape_df)
+    
+    # 2. Collect patterns to train (ignore empty/all -1 patterns)
+    patterns_to_train = []
+    if np.any(p1 == 1):
+        patterns_to_train.append(flatten(p1))
+    if np.any(p2 == 1):
+        patterns_to_train.append(flatten(p2))
+    if np.any(p3 == 1):
+        patterns_to_train.append(flatten(p3))
+        
+    # 3. Check if any patterns were provided
+    if not patterns_to_train:
+        fig_shape = plt.figure()
+        plt.title("Error: No patterns provided to train.")
+        plt.axis('off')
+        
+        fig_energy = plt.figure()
+        plt.title("Error: No patterns provided to train.")
+        
+        return fig_shape, fig_energy
+
+    # 4. Create and train the model
+    patts = np.array(patterns_to_train)
+    model = Hopfield(patts)
+    model.train()
+
+    # 5. Run the evolution
+    current_shape = initial_shape
+    for _ in range(int(steps)):
+        next_shape = model.update(current_shape)
+        # Check for convergence
+        if np.array_equal(current_shape, next_shape):
+            break
+        current_shape = next_shape
+        
+    # 6. Generate final shape plot
+    fig_shape = plt.figure()
+    plt.imshow(current_shape, cmap='gray', vmin=-1, vmax=1)
+    plt.title("Final Evolved Shape")
+    plt.axis('off')
+
+    # 7. Generate energy plot
+    fig_energy = plt.figure()
+    energy_data = model.Energy()
+    if energy_data:
+        plt.plot(list(range(len(energy_data))), energy_data, marker='o')
+        plt.title("Energy Evolution")
+        plt.xlabel("Update Step")
+        plt.ylabel("Energy")
+        plt.grid(True)
+    else:
+        plt.title("Energy (No Updates Run)")
+
+    return fig_shape, fig_energy
+
+# --- Gradio Interface ---
+
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 🧠 Hopfield Network Simulator")
+    gr.Markdown(
+        "Define up to 3 patterns (1 for 'on', -1 for 'off'). "
+        "The network will learn them. Then, draw an 'Initial Shape' "
+        "and see if the network can evolve it into one of the patterns it learned."
+    )
+    
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("### 1. Define Patterns to Memorize")
+            # Set headers to be invisible, type to pandas for .fillna
+            patt1_in = gr.Dataframe(
+                value=patt_1_default,
+                label="Pattern 1",
+                headers=None,
+                datatype="number",
+                col_count=4,
+                row_count=4,
+                type="pandas"
+            )
+            patt2_in = gr.Dataframe(
+                value=patt_2_default,
+                label="Pattern 2",
+                headers=None,
+                datatype="number",
+                col_count=4,
+                row_count=4,
+                type="pandas"
+            )
+            patt3_in = gr.Dataframe(
+                value=patt_3_default,
+                label="Pattern 3",
+                headers=None,
+                datatype="number",
+                col_count=4,
+                row_count=4,
+                type="pandas"
+            )
+        
+        with gr.Column():
+            gr.Markdown("### 2. Set Initial Shape & Run")
+            initial_in = gr.Dataframe(
+                value=initial_shape_default,
+                label="Initial Shape (Test Pattern)",
+                headers=None,
+                datatype="number",
+                col_count=4,
+                row_count=4,
+                type="pandas"
+            )
+            steps_in = gr.Slider(
+                minimum=1,
+                maximum=10,
+                value=5,
+                step=1,
+                label="Max Evolution Steps"
+            )
+            run_btn = gr.Button("Run Evolution", variant="primary")
+
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("### 3. Results")
+            shape_out = gr.Plot(label="Final Evolved Shape")
+        with gr.Column():
+            gr.Markdown("### 4. Diagnostics")
+            energy_out = gr.Plot(label="Energy Evolution")
+
+    # Connect the button to the function
+    run_btn.click(
+        fn=run_hopfield,
+        inputs=[patt1_in, patt2_in, patt3_in, initial_in, steps_in],
+        outputs=[shape_out, energy_out]
+    )
+
+if __name__ == "__main__":
+    demo.launch()