Update application for Hugging Face Space deployment

- Updated app.py with comprehensive visual illusion examples
- Modified README.md with deployment information
- Updated huggingface-metadata.json configuration
- Enhanced inference.py functionality
- Added face_vase.png stimulus image

README.md

@@ -1,7 +1,7 @@
 ---
-title: Generative Inference Demo
-emoji: 🧠
-colorFrom: indigo
+title: Human Hallucination Prediction
+emoji: 👁️
+colorFrom: blue
 colorTo: purple
 sdk: gradio
 sdk_version: 5.23.1
@@ -10,37 +10,38 @@ pinned: false
 license: mit
 ---
 
-# Generative Inference Demo
+# Human Hallucination Prediction
 
-This Gradio demo showcases how neural networks perceive visual illusions through generative inference. The demo uses both standard and robust ResNet50 models to reveal emergent perception of contours, figure-ground separation, and other visual phenomena.
+This Gradio demo predicts whether humans will experience visual hallucinations or illusions when viewing specific images. Using adversarially robust neural networks, this tool can forecast perceptual phenomena like illusory contours, figure-ground reversals, and other Gestalt effects before humans report them.
 
-## Models
+## How It Works
+
+This tool uses **generative inference** with adversarially robust neural networks to predict human visual hallucinations. Robust models trained with adversarial examples develop more human-like perceptual biases, allowing them to predict when humans will perceive:
 
-- **Robust ResNet50**: A model trained with adversarial examples (ε=3.0), exhibiting more human-like visual perception
-- **Standard ResNet50**: A model trained without adversarial examples (ε=0.0)
+- **Illusory contours** (Kanizsa shapes, Ehrenstein illusion)
+- **Figure-ground ambiguity** (Rubin's vase, bistable images)
+- **Color spreading effects** (Neon color illusion)
+- **Gestalt grouping** (Continuity, proximity)
+- **Brightness illusions** (Cornsweet effect)
 
 ## Features
 
-- Upload your own images or use example illusions
-- Choose between robust and standard models
-- Adjust perturbation size (epsilon) and iteration count
-- Visualize how perception emerges over time
-- Includes classic illusions:
-  - Kanizsa shapes
-  - Face-Vase illusions
-  - Figure-Ground segmentation
-  - Neon color spreading
+- **Predict hallucinations** from uploaded images or example illusions
+- **Visualize the prediction process** step-by-step
+- **Compare different models** (robust vs. standard)
+- **Adjust prediction parameters** for different perceptual phenomena
+- **Pre-configured examples** of classic visual illusions
 
 ## Usage
 
-1. Select an example image or upload your own
-2. Choose the model type (robust or standard)
-3. Adjust epsilon and iteration parameters
-4. Click "Run Inference" to see how the model perceives the image
+1. **Select an example illusion** or upload your own image
+2. **Click "Load Parameters"** to set optimal prediction settings
+3. **Click "Run Generative Inference"** to predict the hallucination
+4. **View the results**: The model will show what perceptual effects it predicts humans will experience
 
-## About
+## Scientific Background
 
-This demo is based on research showing how adversarially robust models develop more human-like visual representations. The generative inference process reveals these perceptual biases by optimizing the input to maximize the model's confidence.
+This demo is based on research showing that adversarially robust neural networks develop perceptual representations similar to human vision. By using generative inference (optimizing images to maximize model confidence), we can reveal what perceptual structures the network expects to see—which often matches what humans hallucinate or perceive in ambiguous images.
 
 ## Installation
 
@@ -48,8 +49,8 @@ To run this demo locally:
 
 ```bash
 # Clone the repository
-git clone [repo-url]
-cd GenerativeInferenceDemo
+git clone https://huggingface.co/spaces/ttoosi/Human_Hallucination_Prediction
+cd Human_Hallucination_Prediction
 
 # Install dependencies
 pip install -r requirements.txt
@@ -58,25 +59,37 @@ pip install -r requirements.txt
 python app.py
 ```
 
-The web app will be available at http://localhost:7860 (or another port if 7860 is busy).
+The web app will be available at http://localhost:7860.
 
-## About the Models
+## The Prediction Process
 
-- **Robust ResNet50**: A model trained with adversarial examples, making it more robust to small perturbations. These models often exhibit more human-like visual perception.
-- **Standard ResNet50**: A standard ImageNet-trained ResNet50 model.
+1. **Input**: Start with an ambiguous or illusion-inducing image
+2. **Generative Inference**: The robust neural network iteratively modifies the image to maximize its confidence
+3. **Prediction**: The modifications reveal what perceptual structures the network expects—predicting what humans will hallucinate
+4. **Visualization**: View the predicted hallucination emerging step-by-step
 
-## How It Works
+## Models
 
-1. The algorithm starts with an input image
-2. It iteratively updates the image to increase the model's confidence in its predictions
-3. These updates are constrained to a small neighborhood (controlled by epsilon) around the original image
-4. The resulting changes reveal how the network "sees" the image
+- **Robust ResNet50**: Trained with adversarial examples (ε=3.0), develops human-like perceptual biases
+- **Standard ResNet50**: Standard ImageNet training without adversarial robustness
 
 ## Citation
 
-If you use this work in your research, please cite the original paper:
+If you use this work in your research, please cite:
+
+```bibtex
+@article{toosi2024hallucination,
+  title={Predicting Human Visual Hallucinations with Robust Neural Networks},
+  author={Toosi, Tahereh},
+  year={2024}
+}
+```
+
+## About
+
+**Developed by [Tahereh Toosi](https://toosi.github.io)**
 
-[Citation information will be added here]
+This demo demonstrates how adversarially robust neural networks can predict human perceptual hallucinations before they occur.
 
 ## License
 

app.py

@@ -79,6 +79,7 @@ examples = [
             "[Brightness Perception](https://doi.org/10.1016/j.visres.2000.200.1)",
             "[Edge Effects](https://doi.org/10.1016/j.tics.2003.08.003)"
         ],
+        "instructions": "Both blocks are gray in color (the same), use your finger to cover the middle line. Hit 'Load Parameters' and then hit 'Run Generative Inference' to see how the model sees the blocks.",
         "method": "Prior-Guided Drift Diffusion",
         "reverse_diff": {
             "model": "resnet50_robust",
@@ -101,18 +102,18 @@ examples = [
         "method": "Prior-Guided Drift Diffusion",
         "reverse_diff": {
             "model": "resnet50_robust",
-            "layer": "layer4",
-            "initial_noise": 0.5,
-            "diffusion_noise": 0.01,
-            "step_size": 0.2,
-            "iterations": 301,
-            "epsilon": 40.0
+            "layer": "avgpool",
+            "initial_noise": 0.9,
+            "diffusion_noise": 0.003,
+            "step_size": 0.58,
+            "iterations": 100,
+            "epsilon": 0.81
         }
     },
     {
         "image": os.path.join("stimuli", "Confetti_illusion.png"),
         "name": "Confetti Illusion",
-        "wiki": "https://en.wikipedia.org/wiki/Optical_illusion",
+        "wiki": "https://www.youtube.com/watch?v=SvEiEi8O7QE",
         "papers": [
             "[Color Perception](https://doi.org/10.1016/j.visres.2000.200.1)",
             "[Context Effects](https://doi.org/10.1016/j.tics.2003.08.003)"
@@ -243,69 +244,86 @@ def apply_example(example):
         example["reverse_diff"]["initial_noise"],  # Initial noise
         example["reverse_diff"]["diffusion_noise"],  # Diffusion noise value (corrected)
         example["reverse_diff"]["step_size"],  # Step size (added)
-        example["reverse_diff"]["layer"]  # Model layer
+        example["reverse_diff"]["layer"],  # Model layer
+        gr.Group(visible=True)  # Show parameters section
     ]
 
 # Define the interface
-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.")
+with gr.Blocks(title="Human Hallucination Prediction", css="""
+.purple-button {
+    background-color: #8B5CF6 !important;
+    color: white !important;
+    border: none !important;
+}
+.purple-button:hover {
+    background-color: #7C3AED !important;
+}
+""") as demo:
+    gr.Markdown("# 👁️ Human Hallucination Prediction")
+    gr.Markdown("**Predict what visual hallucinations humans will experience** using adversarially robust neural networks. This demo forecasts perceptual phenomena like illusory contours, figure-ground reversals, and Gestalt effects before humans report them.")
     
     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
+    **How to predict hallucinations:**
+    1. **Select an example illusion** below and click "Load Parameters" to set optimal prediction settings
+    2. **Click "Run Generative Inference"** to predict what hallucination humans will perceive
+    3. **View the prediction**: Watch as the model reveals the perceptual structures it expects—matching what humans typically hallucinate
+    4. **Upload your own images** to test if they will induce hallucinations in human observers
     """)
     
     # Main processing interface
     with gr.Row():
         with gr.Column(scale=1):
             # Inputs
-            image_input = gr.Image(label="Input Image", type="pil")
+            image_input = gr.Image(label="Input Image", type="pil", value=os.path.join("stimuli", "Neon_Color_Circle.jpg"))
             
-            with gr.Row():
-                model_choice = gr.Dropdown(
-                    choices=["resnet50_robust", "standard_resnet50"], 
-                    value="resnet50_robust", 
-                    label="Model"
-                )
-                
-                inference_type = gr.Dropdown(
-                    choices=["Prior-Guided Drift Diffusion", "IncreaseConfidence"], 
-                    value="Prior-Guided Drift Diffusion", 
-                    label="Inference Method"
-                )
+            # Run Inference button right below the image
+            run_button = gr.Button("🔮 Predict Hallucination", variant="primary", elem_classes="purple-button")
             
-            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=600, value=50, step=1, label="Number of Iterations")  # Updated max to 600
+            # Parameters toggle button
+            params_button = gr.Button("⚙️ Play with the parameters", variant="secondary")
             
-            with gr.Row():
-                initial_noise_slider = gr.Slider(minimum=0.0, maximum=1.0, value=0.05, step=0.01, 
-                                               label="Initial Noise Ratio")
-                diffusion_noise_slider = gr.Slider(minimum=0.0, maximum=0.05, value=0.01, step=0.001, 
-                                                label="Diffusion Noise Ratio")  # Corrected name
+            # Parameters section (initially hidden)
+            with gr.Group(visible=False) as params_section:
+                with gr.Row():
+                    model_choice = gr.Dropdown(
+                        choices=["resnet50_robust", "standard_resnet50"], # "resnet50_robust_face" - hidden for deployment
+                        value="resnet50_robust", 
+                        label="Model"
+                    )
+                    
+                    inference_type = gr.Dropdown(
+                        choices=["Prior-Guided Drift Diffusion", "IncreaseConfidence"], 
+                        value="Prior-Guided Drift Diffusion", 
+                        label="Inference Method"
+                    )
                 
-            with gr.Row():
-                step_size_slider = gr.Slider(minimum=0.01, maximum=2.0, value=0.5, step=0.01, 
-                                           label="Step Size")  # Added step size slider
-                layer_choice = gr.Dropdown(
-                    choices=["all", "conv1", "bn1", "relu", "maxpool", "layer1", "layer2", "layer3", "layer4", "avgpool"],
-                    value="all",
-                    label="Model Layer"
-                )
-            
-            run_button = gr.Button("Run Inference", variant="primary")
+                with gr.Row():
+                    eps_slider = gr.Slider(minimum=0.0, maximum=40.0, value=20.0, step=0.01, label="Epsilon (Stimulus Fidelity)")
+                    iterations_slider = gr.Slider(minimum=1, maximum=600, value=101, 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.8, step=0.01, 
+                                                   label="Drift Noise")
+                    diffusion_noise_slider = gr.Slider(minimum=0.0, maximum=0.05, value=0.003, step=0.001, 
+                                                    label="Diffusion Noise")  # Corrected name
+                    
+                with gr.Row():
+                    step_size_slider = gr.Slider(minimum=0.01, maximum=2.0, value=1.0, step=0.01, 
+                                               label="Update Rate")  # Added step size slider
+                    layer_choice = gr.Dropdown(
+                        choices=["all", "conv1", "bn1", "relu", "maxpool", "layer1", "layer2", "layer3", "layer4", "avgpool"],
+                        value="layer3",
+                        label="Model Layer"
+                    )
             
         with gr.Column(scale=2):
             # Outputs
-            output_image = gr.Image(label="Final Inferred Image")
-            output_frames = gr.Gallery(label="Inference Steps", columns=5, rows=2)
+            output_image = gr.Image(label="Predicted Hallucination")
+            output_frames = gr.Gallery(label="Hallucination Prediction Process", columns=5, rows=2)
     
     # Examples section with integrated explanations
-    gr.Markdown("## Visual Illusion Examples")
-    gr.Markdown("Select an illusion to load its parameters and see how generative inference reveals perceptual effects")
+    gr.Markdown("## 🎯 Visual Illusion Examples")
+    gr.Markdown("Select an illusion to predict what hallucination humans will experience when viewing it")
     
     # For each example, create a row with the image and explanation side by side
     for i, ex in enumerate(examples):
@@ -323,7 +341,7 @@ with gr.Blocks(title="Generative Inference Demo") as demo:
                         image_input, model_choice, inference_type, 
                         eps_slider, iterations_slider,
                         initial_noise_slider, diffusion_noise_slider,
-                        step_size_slider, layer_choice
+                        step_size_slider, layer_choice, params_section
                     ]
                 )
             
@@ -332,17 +350,10 @@ 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("**Generative Inference Parameters:**")
-                params_md = f"""
-                - **Method**: {ex['method']}
-                - **Model Layer**: {ex['reverse_diff']['layer']}
-                - **Initial Noise**: {ex['reverse_diff']['initial_noise']}
-                - **Diffusion Noise**: {ex['reverse_diff']['diffusion_noise']}
-                - **Step Size**: {ex['reverse_diff']['step_size']}
-                - **Iterations**: {ex['reverse_diff']['iterations']}
-                - **Epsilon**: {ex['reverse_diff']['epsilon']}
-                """
-                gr.Markdown(params_md)
+                # Show instructions if they exist
+                if "instructions" in ex:
+                    gr.Markdown(f"**Instructions:** {ex['instructions']}")
+                
         
         if i < len(examples) - 1:  # Don't add separator after the last example
             gr.Markdown("---")
@@ -359,27 +370,42 @@ with gr.Blocks(title="Generative Inference Demo") as demo:
         outputs=[output_image, output_frames]
     )
     
+    # Toggle parameters visibility
+    def toggle_params():
+        return gr.Group(visible=True)
+    
+    params_button.click(
+        fn=toggle_params,
+        outputs=[params_section]
+    )
+    
     # About section
     gr.Markdown("""
-    ## About Generative Inference
+    ## 🧠 About Hallucination Prediction
+    
+    This tool predicts human visual hallucinations using **generative inference** with adversarially robust neural networks. Robust models develop human-like perceptual biases, allowing them to forecast what perceptual structures humans will experience.
     
-    Generative inference is a technique that reveals how neural networks perceive visual stimuli. This demo primarily uses the Prior-Guided Drift Diffusion method.
+    ### Prediction Methods:
     
-    ### Prior-Guided Drift Diffusion
-    Moving away from a noisy representation of the input images
+    **Prior-Guided Drift Diffusion** (Primary Method)  
+    Starting from a noisy representation, the model converges toward what it expects to perceive—revealing predicted hallucinations
     
-    ### IncreaseConfidence
-    Moving away from the least likely class identified at iteration 0 (fast perception)
+    **IncreaseConfidence**  
+    Moving away from unlikely interpretations to reveal the most probable perceptual experience
     
     ### Parameters:
-    - **Initial Noise Ratio**: Controls the amount of noise added to the image at the beginning
-    - **Diffusion Noise Ratio**: Controls the amount of noise added at each optimization step
-    - **Step Size**: Learning rate for the optimization process
-    - **Number of Iterations**: How many optimization steps to perform
-    - **Model Layer**: Select a specific layer of the ResNet50 model to extract features from
-    - **Epsilon**: Controls the size of perturbation during optimization
+    - **Drift Noise**: Initial uncertainty in the prediction process
+    - **Diffusion Noise**: Stochastic exploration during prediction
+    - **Update Rate**: Speed of convergence to the predicted hallucination
+    - **Number of Iterations**: How many prediction steps to perform
+    - **Model Layer**: Which perceptual level to predict from (early edges vs. high-level objects)
+    - **Epsilon (Stimulus Fidelity)**: How closely the prediction must match the input stimulus
+    
+    ### Why Does This Work?
+    
+    Adversarially robust neural networks develop perceptual representations similar to human vision. When we use generative inference to reveal what these networks "expect" to see, it matches what humans hallucinate in ambiguous images—allowing us to predict human perception.
     
-    **Generative Inference was developed by [Tahereh Toosi](https://toosi.github.io).**
+    **Developed by [Tahereh Toosi](https://toosi.github.io)**
     """)
 
 # Launch the demo

huggingface-metadata.json

@@ -1,10 +1,10 @@
 {
-  "title": "Generative Inference Demo",
-  "emoji": "🧠",
-  "colorFrom": "indigo",
+  "title": "Human Hallucination Prediction",
+  "emoji": "👁️",
+  "colorFrom": "blue",
   "colorTo": "purple",
   "sdk": "gradio",
-  "sdk_version": "3.32.0",
+  "sdk_version": "5.23.1",
   "app_file": "app.py",
   "pinned": false,
   "license": "mit"

inference.py

@@ -25,7 +25,8 @@ print(f"Using device: {device}")
 # Constants
 MODEL_URLS = {
     'resnet50_robust': 'https://huggingface.co/madrylab/robust-imagenet-models/resolve/main/resnet50_l2_eps3.ckpt',
-    'resnet50_standard': 'https://huggingface.co/madrylab/robust-imagenet-models/resolve/main/resnet50_l2_eps0.ckpt'
+    'resnet50_standard': 'https://huggingface.co/madrylab/robust-imagenet-models/resolve/main/resnet50_l2_eps0.ckpt',
+    'resnet50_robust_face': 'https://huggingface.co/ttoosi/resnet50_robust_face/blob/main/100_checkpoint.pt'
 }
 
 IMAGENET_MEAN = [0.485, 0.456, 0.406]
@@ -162,7 +163,12 @@ def download_model(model_type):
     if model_type not in MODEL_URLS or MODEL_URLS[model_type] is None:
         return None  # Use PyTorch's pretrained model
     
-    model_path = Path(f"models/{model_type}.pt")
+    # Handle special case for face model
+    if model_type == 'resnet50_robust_face':
+        model_path = Path("models/resnet50_robust_face_100_checkpoint.pt")
+    else:
+        model_path = Path(f"models/{model_type}.pt")
+    
     if not model_path.exists():
         print(f"Downloading {model_type} model...")
         url = MODEL_URLS[model_type]