added saving rady to be deployed

app.py

@@ -10,7 +10,10 @@ except ImportError:
         return func
     
 import os
+import re
+import json
 import argparse
+from datetime import datetime
 from inference import GenerativeInferenceModel, get_inference_configs, get_imagenet_labels
 
 # Parse command line arguments
@@ -21,6 +24,8 @@ args = parser.parse_args()
 # Create model directories if they don't exist
 os.makedirs("models", exist_ok=True)
 os.makedirs("stimuli", exist_ok=True)
+SAVED_RUNS_DIR = "saved_runs"
+os.makedirs(SAVED_RUNS_DIR, exist_ok=True)
 
 # Load ImageNet labels for biased-inference dropdown (1000 classes)
 IMAGENET_LABELS = get_imagenet_labels()
@@ -361,16 +366,68 @@ examples = [
     }
 ]
 
+def _input_image_stem(image):
+    """Return a safe filename stem from the input image: known name or 'user_img'."""
+    if image is None:
+        return "user_img"
+    path = None
+    if isinstance(image, str) and (os.path.isfile(image) or os.path.exists(image)):
+        path = image
+    if isinstance(image, dict) and image.get("path") and os.path.exists(image.get("path", "")):
+        path = image["path"]
+    if path:
+        name = os.path.splitext(os.path.basename(path))[0]
+        # Safe for filenames: alphanumeric, underscore, hyphen only; max length
+        safe = re.sub(r"[^\w\-]", "_", name).strip("_") or "user_img"
+        return safe[:80] if len(safe) > 80 else safe
+    return "user_img"
+
+
+def _get_image_path_for_stem(img):
+    """Extract file path from Gradio image value (path string, dict with path, or PIL) for stem tracking."""
+    if img is None:
+        return ""
+    if isinstance(img, str) and (os.path.isfile(img) or os.path.exists(img)):
+        return img
+    if isinstance(img, dict) and img.get("path"):
+        p = img["path"]
+        if isinstance(p, str) and os.path.exists(p):
+            return p
+    return ""
+
+
+def _update_tracked_image_path(img):
+    """Keep path only when it's a known stimulus (e.g. from stimuli/); else '' so stem is 'user_img'."""
+    path = _get_image_path_for_stem(img)
+    if path and "stimuli" in path:
+        return path
+    return ""
+
+
+def _config_to_json_serializable(c):
+    """Return a copy of config with only JSON-serializable values."""
+    if isinstance(c, dict):
+        return {k: _config_to_json_serializable(v) for k, v in c.items()}
+    if isinstance(c, (list, tuple)):
+        return [_config_to_json_serializable(x) for x in c]
+    if isinstance(c, (bool, int, float, str, type(None))):
+        return c
+    if hasattr(c, "item"):  # e.g. numpy scalar
+        return c.item()
+    return str(c)
+
+
 @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",
                  use_adaptive_eps=False, use_adaptive_step=False,
                  mask_center_x=0.0, mask_center_y=0.0, mask_radius=0.3, mask_sigma=0.2,
                  eps_max_mult=4.0, eps_min_mult=1.0, step_max_mult=4.0, step_min_mult=1.0,
-                 use_biased_inference=False, biased_class_name=""):
+                 use_biased_inference=False, biased_class_name="",
+                 current_image_path=""):
     # Check if image is provided
     if image is None:
-        return None, "Please upload an image before running inference."
+        return None, [], "Please upload an image before running inference.", None
     
     # Convert eps to float
     eps = float(eps_value)
@@ -453,8 +510,36 @@ def run_inference(image, model_type, inference_type, eps_value, num_iterations,
     # Convert the final output image to PIL
     final_image = Image.fromarray((output_image.permute(1, 2, 0).cpu().numpy() * 255).astype(np.uint8))
     
-    # Return the final inferred image and the animation frames directly
-    return final_image, frames
+    # Always save GIF and config and offer as downloads (browser will ask where to save)
+    save_status = ""
+    files_for_download = None
+    if frames:
+        # Use tracked path when available (e.g. from Load Parameters); else derive from image (PIL loses path)
+        stem = _input_image_stem(current_image_path if (current_image_path and current_image_path.strip()) else image)
+        unique_id = f"{datetime.now().strftime('%Y%m%d_%H%M%S')}_{stem}"
+        gif_path = os.path.join(SAVED_RUNS_DIR, f"{unique_id}.gif")
+        config_path = os.path.join(SAVED_RUNS_DIR, f"{unique_id}_config.json")
+        try:
+            frames[0].save(
+                gif_path,
+                save_all=True,
+                append_images=frames[1:],
+                loop=0,
+                duration=200,
+            )
+            save_config = {
+                "model_type": model_type,
+                "input_image_name": stem,
+                **_config_to_json_serializable(config),
+            }
+            with open(config_path, "w") as f:
+                json.dump(save_config, f, indent=2)
+            files_for_download = [gif_path, config_path]
+            save_status = "**Download results** — Use the links below to save the GIF and config to your device (your browser may ask where to save)."
+        except Exception as e:
+            save_status = f"Save failed: {e}"
+    
+    return final_image, frames, save_status, files_for_download
 
 def _image_to_pil(img):
     """Convert Gradio image value (PIL, numpy, path, or dict) to PIL Image; return None if invalid."""
@@ -546,6 +631,7 @@ def apply_example(example):
         example.get("step_min_mult", 1.0),
         example.get("use_biased_inference", False),
         example.get("biased_class_name", ""),
+        example["image"],  # keep path for save filename (e.g. UrbanOffice1 -> urbanoffice1)
         mask_img,
         gr.Group(visible=True),
     ]
@@ -570,11 +656,14 @@ with gr.Blocks(title="Human Hallucination Prediction", css="""
     2. **Click "Run Generative Inference"** to predict what hallucination humans may perceive
     3. **View the prediction**: Watch as the model reveals the perceptual structures it expects—matching what humans typically hallucinate
     4. **You can upload your own images**
+    5. **You can download the results** as a .gif file together with the configs.json
     """)
     with gr.Row():
         with gr.Column(scale=1):
-            # Inputs
-            image_input = gr.Image(label="Input Image (click to set mask center)", type="pil", value=os.path.join("stimuli", "urbanoffice1.jpg"))
+            # Inputs (track path so save filenames use stimulus name when from example)
+            default_image_path = os.path.join("stimuli", "urbanoffice1.jpg")
+            image_input = gr.Image(label="Input Image (click to set mask center)", type="pil", value=default_image_path)
+            current_image_path_state = gr.State(value=default_image_path)
             mask_preview = gr.Image(
                 label="Mask center preview (click to set center — circle shows mask)",
                 type="pil",
@@ -644,15 +733,16 @@ with gr.Blocks(title="Human Hallucination Prediction", css="""
                     biased_class_dropdown = gr.Dropdown(
                         choices=[("— No bias —", "")] + [(label, label) for label in sorted(IMAGENET_LABELS)],
                         value="",
-                        label="Target class",
+                        label="Biased toward category",
                         allow_custom_value=False,
                         filterable=True,
                     )
-            
         with gr.Column(scale=2):
             # Outputs
             output_image = gr.Image(label="Predicted Hallucination")
             output_frames = gr.Gallery(label="Hallucination Prediction Process", columns=5, rows=2)
+            save_status_md = gr.Markdown(value="")
+            download_files = gr.File(label="Download results (GIF + config)", file_count="multiple")
     
     # Examples section with integrated explanations
     gr.Markdown("## Examples")
@@ -681,6 +771,7 @@ with gr.Blocks(title="Human Hallucination Prediction", css="""
                         eps_max_mult_slider, eps_min_mult_slider,
                         step_max_mult_slider, step_min_mult_slider,
                         use_biased_inference_check, biased_class_dropdown,
+                        current_image_path_state,
                         mask_preview,
                         params_section,
                     ],
@@ -689,7 +780,8 @@ with gr.Blocks(title="Human Hallucination Prediction", css="""
             # Right column for the explanation
             with gr.Column(scale=2):
                 gr.Markdown(f"### {ex['name']}")
-                gr.Markdown(f"[Read more on Wikipedia]({ex['wiki']})")
+                if ex["name"] not in ("farm1", "ArtGallery1", "UrbanOffice1"):
+                    gr.Markdown(f"[Read more on Wikipedia]({ex['wiki']})")
                 
                 # Show instructions if they exist
                 if "instructions" in ex:
@@ -713,8 +805,9 @@ with gr.Blocks(title="Human Hallucination Prediction", css="""
             eps_max_mult_slider, eps_min_mult_slider,
             step_max_mult_slider, step_min_mult_slider,
             use_biased_inference_check, biased_class_dropdown,
+            current_image_path_state,
         ],
-        outputs=[output_image, output_frames]
+        outputs=[output_image, output_frames, save_status_md, download_files]
     )
     
     # Toggle parameters visibility
@@ -744,6 +837,12 @@ with gr.Blocks(title="Human Hallucination Prediction", css="""
         inputs=_mask_preview_inputs(),
         outputs=[mask_preview],
     )
+    # Keep tracked path for save filename: known stimulus name or clear so stem becomes 'user_img'
+    image_input.change(
+        fn=_update_tracked_image_path,
+        inputs=[image_input],
+        outputs=[current_image_path_state],
+    )
     mask_center_x_slider.change(
         fn=draw_mask_overlay,
         inputs=_mask_preview_inputs(),