Upload 2 files

local git upload fails so uploading

app.py

@@ -34,98 +34,79 @@ model = GenerativeInferenceModel()
 # Define example images and their parameters with updated values from the research
 examples = [
     {
-        "image": os.path.join("stimuli", "Kanizsa_square.jpg"),
-        "name": "Kanizsa Square",
-        "wiki": "https://en.wikipedia.org/wiki/Kanizsa_triangle",
-        "papers": [
-            "[Gestalt Psychology](https://en.wikipedia.org/wiki/Gestalt_psychology)",
-            "[Neural Mechanisms](https://doi.org/10.1016/j.tics.2003.08.003)"
-        ],
-        "method": "ReverseDiffusion",
-        "reverse_diff": {
-            "model": "resnet50_robust",
-            "layer": "layer4",  # last layer
-            "initial_noise": 0.1,
-            "diffusion_noise": 0.003,  # Corrected parameter name
-            "step_size": 0.5,  # Step size (learning rate parameter)
-            "iterations": 50,  # Number of iterations
-            "epsilon": 0.5
-        }
-    },
-    {
-        "image": os.path.join("stimuli", "face_vase.png"),
-        "name": "Rubin's Face-Vase (Object Prior)",
-        "wiki": "https://en.wikipedia.org/wiki/Rubin_vase",
+        "image": os.path.join("stimuli", "Neon_Color_Circle.jpg"),
+        "name": "Neon Color Spreading",
+        "wiki": "https://en.wikipedia.org/wiki/Neon_color_spreading",
         "papers": [
-            "[Figure-Ground Perception](https://en.wikipedia.org/wiki/Figure-ground_(perception))",
-            "[Bistable Perception](https://doi.org/10.1016/j.tics.2003.08.003)"
+            "[Color Assimilation](https://doi.org/10.1016/j.visres.2000.200.1)",
+            "[Perceptual Filling-in](https://doi.org/10.1016/j.tics.2003.08.003)"
         ],
-        "method": "ReverseDiffusion",
+        "method": "Prior-Guided Drift Diffusion",
         "reverse_diff": {
             "model": "resnet50_robust",
-            "layer": "layer4",  # last layer
-            "initial_noise": 0.7,
-            "diffusion_noise": 0.005,  # Corrected parameter name
-            "step_size": 1.0,  # Step size (learning rate parameter)
-            "iterations": 50,  # Number of iterations
-            "epsilon": 1.0
+            "layer": "layer3",
+            "initial_noise": 0.8,
+            "diffusion_noise": 0.003,
+            "step_size": 1.0,
+            "iterations": 101,
+            "epsilon": 20.0
         }
     },
     {
-        "image": os.path.join("stimuli", "figure_ground.png"),
-        "name": "Figure-Ground Illusion",
-        "wiki": "https://en.wikipedia.org/wiki/Figure-ground_(perception)",
+        "image": os.path.join("stimuli", "Kanizsa_square.jpg"),
+        "name": "Kanizsa Square",
+        "wiki": "https://en.wikipedia.org/wiki/Kanizsa_triangle",
         "papers": [
-            "[Gestalt Principles](https://en.wikipedia.org/wiki/Gestalt_psychology)",
-            "[Perceptual Organization](https://doi.org/10.1016/j.tics.2003.08.003)"
+            "[Gestalt Psychology](https://en.wikipedia.org/wiki/Gestalt_psychology)",
+            "[Neural Mechanisms](https://doi.org/10.1016/j.tics.2003.08.003)"
         ],
-        "method": "ReverseDiffusion",
+        "method": "Prior-Guided Drift Diffusion",
         "reverse_diff": {
             "model": "resnet50_robust",
-            "layer": "layer3",
-            "initial_noise": 0.5,
-            "diffusion_noise": 0.005,  # Corrected parameter name
-            "step_size": 0.8,  # Step size (learning rate parameter)
-            "iterations": 50,  # Number of iterations
-            "epsilon": 0.8
+            "layer": "all",
+            "initial_noise": 0.0,
+            "diffusion_noise": 0.005,
+            "step_size": 0.64,
+            "iterations": 100,
+            "epsilon": 5.0
         }
     },
     {
-        "image": os.path.join("stimuli", "Neon_Color_Circle.jpg"),
-        "name": "Neon Color Spreading",
-        "wiki": "https://en.wikipedia.org/wiki/Neon_color_spreading",
+        "image": os.path.join("stimuli", "CornsweetBlock.png"),
+        "name": "Cornsweet Illusion",
+        "wiki": "https://en.wikipedia.org/wiki/Cornsweet_illusion",
         "papers": [
-            "[Color Assimilation](https://doi.org/10.1016/j.visres.2000.200.1)",
-            "[Perceptual Filling-in](https://doi.org/10.1016/j.tics.2003.08.003)"
+            "[Brightness Perception](https://doi.org/10.1016/j.visres.2000.200.1)",
+            "[Edge Effects](https://doi.org/10.1016/j.tics.2003.08.003)"
         ],
-        "method": "ReverseDiffusion",
+        "method": "Prior-Guided Drift Diffusion",
         "reverse_diff": {
             "model": "resnet50_robust",
             "layer": "layer3",
             "initial_noise": 0.5,
-            "diffusion_noise": 0.003,  # Corrected parameter name
-            "step_size": 1.0,  # Step size (learning rate parameter)
-            "iterations": 50,  # Number of iterations
-            "epsilon": 1.0
+            "diffusion_noise": 0.005,
+            "step_size": 0.8,
+            "iterations": 51,
+            "epsilon": 20.0
         }
     },
     {
-        "image": os.path.join("stimuli", "EhresteinSingleColor.png"),
-        "name": "Ehrenstein Illusion",
-        "wiki": "https://en.wikipedia.org/wiki/Ehrenstein_illusion",
+        "image": os.path.join("stimuli", "face_vase.png"),
+        "name": "Rubin's Face-Vase (Object Prior)",
+        "wiki": "https://en.wikipedia.org/wiki/Rubin_vase",
         "papers": [
-            "[Subjective Contours](https://doi.org/10.1016/j.visres.2000.200.1)",
-            "[Neural Processing](https://doi.org/10.1016/j.tics.2003.08.003)"
+            "[Figure-Ground Perception](https://en.wikipedia.org/wiki/Figure-ground_(perception))",
+            "[Bistable Perception](https://doi.org/10.1016/j.tics.2003.08.003)"
         ],
-        "method": "ReverseDiffusion",
+        "method": "Prior-Guided Drift Diffusion",
         "reverse_diff": {
             "model": "resnet50_robust",
-            "layer": "layer3",
+            "layer": "layer4",
             "initial_noise": 0.5,
-            "diffusion_noise": 0.005,  # Corrected parameter name
-            "step_size": 0.8,  # Step size (learning rate parameter)
-            "iterations": 50,  # Number of iterations
-            "epsilon": 0.8
+            "diffusion_noise": 0.01,
+            "step_size": 0.2,
+            "iterations": 301,
+            "epsilon": 40.0
         }
     },
     {
@@ -136,34 +117,34 @@ examples = [
             "[Color Perception](https://doi.org/10.1016/j.visres.2000.200.1)",
             "[Context Effects](https://doi.org/10.1016/j.tics.2003.08.003)"
         ],
-        "method": "ReverseDiffusion",
+        "method": "Prior-Guided Drift Diffusion",
         "reverse_diff": {
             "model": "resnet50_robust",
             "layer": "layer3",
-            "initial_noise": 0.7,
-            "diffusion_noise": 0.01,  # Corrected parameter name
-            "step_size": 1.0,  # Step size (learning rate parameter)
-            "iterations": 50,  # Number of iterations
-            "epsilon": 1.0
+            "initial_noise": 0.1,
+            "diffusion_noise": 0.003,
+            "step_size": 0.5,
+            "iterations": 101,
+            "epsilon": 20.0
         }
     },
     {
-        "image": os.path.join("stimuli", "CornsweetBlock.png"),
-        "name": "Cornsweet Illusion",
-        "wiki": "https://en.wikipedia.org/wiki/Cornsweet_illusion",
+        "image": os.path.join("stimuli", "EhresteinSingleColor.png"),
+        "name": "Ehrenstein Illusion",
+        "wiki": "https://en.wikipedia.org/wiki/Ehrenstein_illusion",
         "papers": [
-            "[Brightness Perception](https://doi.org/10.1016/j.visres.2000.200.1)",
-            "[Edge Effects](https://doi.org/10.1016/j.tics.2003.08.003)"
+            "[Subjective Contours](https://doi.org/10.1016/j.visres.2000.200.1)",
+            "[Neural Processing](https://doi.org/10.1016/j.tics.2003.08.003)"
         ],
-        "method": "ReverseDiffusion",
+        "method": "Prior-Guided Drift Diffusion",
         "reverse_diff": {
             "model": "resnet50_robust",
             "layer": "layer3",
             "initial_noise": 0.5,
-            "diffusion_noise": 0.005,  # Corrected parameter name
-            "step_size": 0.8,  # Step size (learning rate parameter)
-            "iterations": 50,  # Number of iterations
-            "epsilon": 0.8
+            "diffusion_noise": 0.005,
+            "step_size": 0.8,
+            "iterations": 101,
+            "epsilon": 20.0
         }
     },
     {
@@ -174,15 +155,34 @@ examples = [
             "[Gestalt Principles](https://en.wikipedia.org/wiki/Gestalt_psychology)",
             "[Visual Organization](https://doi.org/10.1016/j.tics.2003.08.003)"
         ],
-        "method": "ReverseDiffusion",
+        "method": "Prior-Guided Drift Diffusion",
+        "reverse_diff": {
+            "model": "resnet50_robust",
+            "layer": "layer3",
+            "initial_noise": 0.0,
+            "diffusion_noise": 0.005,
+            "step_size": 0.4,
+            "iterations": 101,
+            "epsilon": 4.0
+        }
+    },
+    {
+        "image": os.path.join("stimuli", "figure_ground.png"),
+        "name": "Figure-Ground Illusion",
+        "wiki": "https://en.wikipedia.org/wiki/Figure-ground_(perception)",
+        "papers": [
+            "[Gestalt Principles](https://en.wikipedia.org/wiki/Gestalt_psychology)",
+            "[Perceptual Organization](https://doi.org/10.1016/j.tics.2003.08.003)"
+        ],
+        "method": "Prior-Guided Drift Diffusion",
         "reverse_diff": {
             "model": "resnet50_robust",
             "layer": "layer3",
             "initial_noise": 0.1,
-            "diffusion_noise": 0.005,  # Corrected parameter name
-            "step_size": 0.4,  # Step size (learning rate parameter)
-            "iterations": 100,  # Number of iterations
-            "epsilon": 0.4
+            "diffusion_noise": 0.003,
+            "step_size": 0.5,
+            "iterations": 101,
+            "epsilon": 3.0
         }
     }
 ]
@@ -190,14 +190,18 @@ examples = [
 @GPU 
 def run_inference(image, model_type, inference_type, eps_value, num_iterations, 
                  initial_noise=0.05, diffusion_noise=0.3, step_size=0.8, model_layer="layer3"):
+    # Check if image is provided
+    if image is None:
+        return None, "Please upload an image before running inference."
+    
     # Convert eps to float
     eps = float(eps_value)
     
     # Load inference configuration based on the selected type
     config = get_inference_configs(inference_type=inference_type, eps=eps, n_itr=int(num_iterations))
     
-    # Handle ReverseDiffusion specific parameters
-    if inference_type == "ReverseDiffusion":
+    # Handle Prior-Guided Drift Diffusion specific parameters
+    if inference_type == "Prior-Guided Drift Diffusion":
         config['initial_inference_noise_ratio'] = float(initial_noise)
         config['diffusion_noise_ratio'] = float(diffusion_noise)
         config['step_size'] = float(step_size)  # Added step size parameter
@@ -247,6 +251,13 @@ with gr.Blocks(title="Generative Inference Demo") as demo:
     gr.Markdown("# Generative Inference Demo")
     gr.Markdown("This demo showcases how neural networks can perceive visual illusions through generative inference.")
     
+    gr.Markdown("""
+    **How to use this demo:**
+    - **Load pre-configured examples**: Click on any visual illusion below and hit "Load Parameters" to automatically set up the optimal parameters for that illusion
+    - **Upload your own images**: Use the image upload area to test your own images with different parameter settings
+    - **Experiment with parameters**: Adjust the inference method, iterations, noise levels, and other parameters to see how they affect the generative inference process
+    """)
+    
     # Main processing interface
     with gr.Row():
         with gr.Column(scale=1):
@@ -261,14 +272,14 @@ with gr.Blocks(title="Generative Inference Demo") as demo:
                 )
                 
                 inference_type = gr.Dropdown(
-                    choices=["ReverseDiffusion", "IncreaseConfidence"], 
-                    value="ReverseDiffusion", 
+                    choices=["Prior-Guided Drift Diffusion", "IncreaseConfidence"], 
+                    value="Prior-Guided Drift Diffusion", 
                     label="Inference Method"
                 )
             
             with gr.Row():
                 eps_slider = gr.Slider(minimum=0.01, maximum=3.0, value=0.5, step=0.01, label="Epsilon (Perturbation Size)")
-                iterations_slider = gr.Slider(minimum=1, maximum=50, value=50, step=1, label="Number of Iterations")  # Default 50
+                iterations_slider = gr.Slider(minimum=1, maximum=600, value=50, step=1, label="Number of Iterations")  # Updated max to 600
             
             with gr.Row():
                 initial_noise_slider = gr.Slider(minimum=0.0, maximum=1.0, value=0.05, step=0.01, 
@@ -321,11 +332,7 @@ with gr.Blocks(title="Generative Inference Demo") as demo:
                 gr.Markdown(f"### {ex['name']}")
                 gr.Markdown(f"[Read more on Wikipedia]({ex['wiki']})")
                 
-                gr.Markdown("**Previous Explanations:**")
-                papers_list = "\n".join([f"- {paper}" for paper in ex["papers"]])
-                gr.Markdown(papers_list)
-                
-                gr.Markdown("**Research Parameters:**")
+                gr.Markdown("**Generative Inference Parameters:**")
                 params_md = f"""
                 - **Method**: {ex['method']}
                 - **Model Layer**: {ex['reverse_diff']['layer']}
@@ -356,15 +363,13 @@ with gr.Blocks(title="Generative Inference Demo") as demo:
     gr.Markdown("""
     ## About Generative Inference
     
-    Generative inference is a technique that reveals how neural networks perceive visual stimuli. This demo primarily uses the ReverseDiffusion method.
+    Generative inference is a technique that reveals how neural networks perceive visual stimuli. This demo primarily uses the Prior-Guided Drift Diffusion method.
     
-    ### ReverseDiffusion
-    Starts with a noisy version of the image and guides the optimization to match features of the noisy image. 
-    This approach reveals different aspects of visual processing and is inspired by diffusion models.
+    ### Prior-Guided Drift Diffusion
+    Moving away from a noisy representation of the input images
     
     ### IncreaseConfidence
-    Optimizes the network's activations to increase confidence in classification, leading to enhanced 
-    features that the network associates with its preferred interpretation.
+    Moving away from the least likely class identified at iteration 0 (fast perception)
     
     ### Parameters:
     - **Initial Noise Ratio**: Controls the amount of noise added to the image at the beginning
@@ -374,8 +379,7 @@ with gr.Blocks(title="Generative Inference Demo") as demo:
     - **Model Layer**: Select a specific layer of the ResNet50 model to extract features from
     - **Epsilon**: Controls the size of perturbation during optimization
     
-    Different layers capture different levels of abstraction - earlier layers represent low-level features
-    like edges and textures, while later layers represent higher-level features and object parts.
+    **Generative Inference was developed by [Tahereh Toosi](https://toosi.github.io).**
     """)
 
 # Launch the demo

inference.py

@@ -213,11 +213,26 @@ class InferStep:
         scaled_grad = grad / (grad_norm + 1e-10)
         return scaled_grad * self.step_size
 
+def get_iterations_to_show(n_itr):
+    """Generate a dynamic list of iterations to show based on total iterations."""
+    if n_itr <= 50:
+        return [1, 5, 10, 20, 30, 40, 50, n_itr]
+    elif n_itr <= 100:
+        return [1, 5, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, n_itr]
+    elif n_itr <= 200:
+        return [1, 5, 10, 20, 30, 40, 50, 75, 100, 125, 150, 175, 200, n_itr]
+    elif n_itr <= 500:
+        return [1, 5, 10, 20, 30, 40, 50, 75, 100, 150, 200, 250, 300, 350, 400, 450, 500, n_itr]
+    else:
+        # For very large iterations, show more evenly distributed points
+        return [1, 5, 10, 20, 30, 40, 50, 75, 100, 150, 200, 250, 300, 350, 400, 450, 500, 
+                int(n_itr*0.6), int(n_itr*0.7), int(n_itr*0.8), int(n_itr*0.9), n_itr]
+
 def get_inference_configs(inference_type='IncreaseConfidence', eps=0.5, n_itr=50, step_size=1.0):
     """Generate inference configuration with customizable parameters.
     
     Args:
-        inference_type (str): Type of inference ('IncreaseConfidence' or 'ReverseDiffusion')
+        inference_type (str): Type of inference ('IncreaseConfidence' or 'Prior-Guided Drift Diffusion')
         eps (float): Maximum perturbation size
         n_itr (int): Number of iterations
         step_size (float): Step size for each iteration
@@ -234,7 +249,7 @@ def get_inference_configs(inference_type='IncreaseConfidence', eps=0.5, n_itr=50
         'top_layer': 'all',  # Use all layers of the model
         'inference_normalization': False,  # Apply normalization during inference
         'recognition_normalization': False,  # Apply normalization during recognition
-        'iterations_to_show': [1, 5, 10, 20, 30, 40, 50, n_itr],  # Specific iterations to visualize
+        'iterations_to_show': get_iterations_to_show(n_itr),  # Dynamic iterations to visualize
         'misc_info': {'keep_grads': False}  # Additional configuration
     }
     
@@ -242,7 +257,7 @@ def get_inference_configs(inference_type='IncreaseConfidence', eps=0.5, n_itr=50
     if inference_type == 'IncreaseConfidence':
         config['loss_function'] = 'CE'  # Cross Entropy
     
-    elif inference_type == 'ReverseDiffusion':
+    elif inference_type == 'Prior-Guided Drift Diffusion':
         config['loss_function'] = 'MSE'  # Mean Square Error
         config['initial_inference_noise_ratio'] = 0.05  # Initial noise for diffusion
         config['diffusion_noise_ratio'] = 0.01  # Add noise during diffusion
@@ -723,11 +738,11 @@ class GenerativeInferenceModel:
         x = image_tensor.clone().detach().requires_grad_(True)
         all_steps = [image_tensor[0].detach().cpu()]
         
-        # For ReverseDiffusion, extract selected layer and initialize with noisy features
+        # For Prior-Guided Drift Diffusion, extract selected layer and initialize with noisy features
         noisy_features = None
         layer_model = None
-        if config['loss_infer'] == 'ReverseDiffusion':
-            print(f"Setting up ReverseDiffusion with layer {config['top_layer']} and noise {config['initial_inference_noise_ratio']}...")
+        if config['loss_infer'] == 'Prior-Guided Drift Diffusion':
+            print(f"Setting up Prior-Guided Drift Diffusion with layer {config['top_layer']} and noise {config['initial_inference_noise_ratio']}...")
             
             # Extract model up to the specified layer
             try:
@@ -774,7 +789,7 @@ class GenerativeInferenceModel:
             # Compute noisy features - simplified to match original code
             noisy_features = layer_model(noisy_image_tensor)
             
-            print(f"Noisy features computed for ReverseDiffusion target with shape: {noisy_features.shape if hasattr(noisy_features, 'shape') else 'unknown'}")
+            print(f"Noisy features computed for Prior-Guided Drift Diffusion target with shape: {noisy_features.shape if hasattr(noisy_features, 'shape') else 'unknown'}")
         
         # Main inference loop
         print(f"Starting inference loop with {config['n_itr']} iterations for {config['loss_infer']}...")
@@ -783,9 +798,9 @@ class GenerativeInferenceModel:
             # Reset gradients
             x.grad = None
             
-            # Forward pass - use layer_model for ReverseDiffusion, full model otherwise
-            if config['loss_infer'] == 'ReverseDiffusion' and layer_model is not None:
-                # Use the extracted layer model for ReverseDiffusion
+            # Forward pass - use layer_model for Prior-Guided Drift Diffusion, full model otherwise
+            if config['loss_infer'] == 'Prior-Guided Drift Diffusion' and layer_model is not None:
+                # Use the extracted layer model for Prior-Guided Drift Diffusion
                 # In original code, normalization is handled at transform time, not during forward pass
                 output = layer_model(x)
             else:
@@ -795,14 +810,14 @@ class GenerativeInferenceModel:
             
             # Calculate loss and gradients based on inference type
             try:
-                if config['loss_infer'] == 'ReverseDiffusion':
+                if config['loss_infer'] == 'Prior-Guided Drift Diffusion':
                     # Use MSE loss to match the noisy features
                     assert config['loss_function'] == 'MSE', "Reverse Diffusion loss function must be MSE"
                     if noisy_features is not None:
                         loss = F.mse_loss(output, noisy_features)
                         grad = torch.autograd.grad(loss, x)[0]  # Removed retain_graph=True to match original
                     else:
-                        raise ValueError("Noisy features not computed for ReverseDiffusion")
+                        raise ValueError("Noisy features not computed for Prior-Guided Drift Diffusion")
                 
                 else:  # Default 'IncreaseConfidence' approach
                     # Get the least confident classes