feat(attack-ui): add ground-truth aware evaluation and sample GT auto-selection

- add a searchable Ground Truth dropdown in the Adversarial Attack + Attention tab
- show the Ground Truth field only when class labels are available from the loaded model
- auto-populate Ground Truth when a sample image is selected, using data/sample_images/metadata.json mapping
- initialize Ground Truth choices on app load for the default model (not only on change events)
- update attack report logic to use Ground Truth as the reference label when provided
- keep backward-compatible fallback to original prediction when Ground Truth is not set
- make class-dependent metrics Ground Truth aware in utils/metrics (ASR, confidence_drop, topk_drop)
- propagate Ground Truth handling to the sweep runner and add ground_truth column to CSV output
- restore correct tab structure so Apuana Cluster UI remains in its own tab
- update README notes to document Ground Truth behavior in class-related metrics

README.md

@@ -111,7 +111,8 @@ cd notebooks && jupyter notebook
 
 - **Perturbação de imagem**: L∞, PSNR, SSIM, LPIPS, Modified Pixels  
 - **Deslocamento de atenção**: Attention W1 (Rollout, padrão), Attention JSD (Rollout)  
-- **Ataque**: ASR, Confidence Drop, Top-k Overlap Drop
+- **Ataque**: ASR, Confidence Drop, Top-k Overlap Drop  
+  - Na aba de ataque, quando **Ground Truth Label** é informado, as métricas de classe usam esse rótulo como referência; sem GT, usam fallback para a predição original.
 
 ## Apuana Cluster Integration (UI)
 

app.py

@@ -145,6 +145,50 @@ def _to_path(file_like: Optional[object]) -> Optional[str]:
         return path
     return None
 
+
+def _load_sample_ground_truth_map(metadata_path: Path) -> Dict[str, int]:
+    """Load sample filename -> ground truth class index mapping from metadata.json."""
+    if not metadata_path.exists():
+        return {}
+    try:
+        with open(metadata_path, "r", encoding="utf-8") as f:
+            payload = json.load(f) or {}
+    except Exception:
+        return {}
+
+    files = payload.get("downloaded_files") or []
+    classes = payload.get("suggested_classes") or []
+    n = min(len(files), len(classes))
+    out: Dict[str, int] = {}
+    for i in range(n):
+        filename = str(files[i]).strip()
+        cls = classes[i] if isinstance(classes[i], dict) else {}
+        cls_id = cls.get("imagenet_id")
+        if not filename:
+            continue
+        try:
+            out[filename] = int(cls_id)
+        except (TypeError, ValueError):
+            continue
+    return out
+
+
+def _build_ground_truth_choices(class_names: Optional[Dict[int, str]]) -> List[Tuple[str, str]]:
+    """Create dropdown choices [(display_label, value)] for ground truth selection."""
+    if not class_names:
+        return []
+
+    normalized: List[Tuple[int, str]] = []
+    for key, value in class_names.items():
+        try:
+            idx = int(key)
+        except (TypeError, ValueError):
+            continue
+        normalized.append((idx, str(value)))
+
+    normalized.sort(key=lambda x: x[0])
+    return [(f"{idx:04d} - {name}", str(idx)) for idx, name in normalized]
+
 def _print_model_heads(model):
     """Imprime quantidade de heads do ViT ao carregar o modelo. Mais usada para debug."""
     try:
@@ -313,6 +357,7 @@ def run_attack(
     decay: float,
     vit_weight: float,
     selected_metrics,
+    ground_truth_label,
 ) -> Tuple[List[Image.Image], str, List[List[torch.Tensor]]]:
     """
     Executa ataque adversarial (FGSM ou PGD) untargeted e extrai atenção.
@@ -385,6 +430,16 @@ def run_attack(
         adv_class = top_idx_adv[0].item()
         adv_prob = top_prob_adv[0].item()
 
+        gt_class: Optional[int] = None
+        if ground_truth_label not in (None, ""):
+            try:
+                gt_class = int(ground_truth_label)
+            except (TypeError, ValueError):
+                gt_class = None
+
+        # If GT is present, class-dependent metrics are evaluated against GT.
+        eval_label = gt_class if gt_class is not None else orig_class
+
         # Resolver seleção de métricas:
         # - sem seleção ou com "Select All" => mostra todas
         # - caso contrário, mostra apenas as escolhidas
@@ -425,9 +480,9 @@ def run_attack(
         if "Modified Pixels" in requested_metrics:
             metric_values["Modified Pixels"] = f"{compute_modified_pixels(img_tensor, adv_tensor):.1f}%"
         if "Confidence Drop" in requested_metrics:
-            metric_values["Confidence Drop"] = f"{compute_confidence_drop(orig_probs_full, adv_probs_full, orig_class):.4f}"
+            metric_values["Confidence Drop"] = f"{compute_confidence_drop(orig_probs_full, adv_probs_full, eval_label):.4f}"
         if "Top-K Accuracy Drop" in requested_metrics:
-            topk_drop = compute_topk_drop(orig_probs_full, adv_probs_full, orig_class, k=5)
+            topk_drop = compute_topk_drop(orig_probs_full, adv_probs_full, eval_label, k=5)
             metric_values["Top-K Accuracy Drop"] = "Yes" if topk_drop >= 0.5 else "No"
 
         metric_tooltips = {
@@ -438,8 +493,8 @@ def run_attack(
             "SSIM": "Structural Similarity Index comparing luminance, contrast, and structure. Values near 1 mean images are structurally similar.",
             "LPIPS": "Learned Perceptual Image Patch Similarity based on deep features. Lower values indicate greater perceptual similarity.",
             "Modified Pixels": "Percentage of pixels where perturbation exceeds 1e-5 (channel max). It approximates a sparse L0/Hamming-like change count.",
-            "Confidence Drop": "Decrease in original-class probability after attack: p_orig(original class) - p_adv(original class). Higher means stronger reduction.",
-            "Top-K Accuracy Drop": "Yes means the original class left top-5 after attack. No means the original class is still in top-5.",
+            "Confidence Drop": "Decrease in reference-class probability after attack: p_orig(reference class) - p_adv(reference class). If Ground Truth is set, reference class = Ground Truth; otherwise it falls back to original prediction.",
+            "Top-K Accuracy Drop": "Yes means the reference class left top-5 after attack. If Ground Truth is set, reference class = Ground Truth; otherwise it falls back to original prediction.",
         }
 
         def metric_label_with_info(label: str, tooltip_text: str) -> str:
@@ -458,7 +513,7 @@ def run_attack(
         result = f"## {attack_type} Attack Result (Untargeted)\n\n"
         
         # Status visual
-        if adv_class != orig_class:
+        if adv_class != eval_label:
             status_icon = ICON_SUCCESS
             status_text = "Success"
         else:
@@ -470,6 +525,18 @@ def run_attack(
         # Prediction Comparison (duas tabelas)
         result += f"### {ICON_CHART} Prediction Comparison (Top-5)\n\n"
 
+        if gt_class is not None:
+            gt_name = None
+            if class_names:
+                gt_name = class_names.get(gt_class) if isinstance(class_names, dict) else None
+                if gt_name is None and isinstance(class_names, dict):
+                    gt_name = class_names.get(str(gt_class))
+            if gt_name is not None:
+                gt_display = f"{gt_name} (class {gt_class})"
+            else:
+                gt_display = f"Class {gt_class}"
+            result += f"**Ground Truth:** {gt_display}\n\n"
+
         top_k_display = min(5, len(top_prob_orig), len(top_prob_adv))
         result += "<div class=\"vitviz-panels\">\n"
 
@@ -1205,6 +1272,13 @@ def create_app():
         height: 100% !important;
         object-fit: contain !important;
     }
+
+    /* Keep native Gradio Gallery captions visible across themes. */
+    .gradio-container .caption-label {
+        color: #111111 !important;
+        background: rgba(255, 255, 255, 0.92) !important;
+        border: 1px solid rgba(0, 0, 0, 0.18) !important;
+    }
     
     @keyframes spin {
         0% { transform: rotate(0deg); }
@@ -1437,6 +1511,13 @@ def create_app():
 
     default_eps_csv = ", ".join(str(v) for v in default_sweep_cfg.get("evaluation", {}).get("epsilons", [0.00784]))
     default_seeds_csv = ", ".join(str(v) for v in default_sweep_cfg.get("evaluation", {}).get("seeds", [42]))
+    sample_images_dir = PROJECT_ROOT / "data" / "sample_images"
+    sample_image_paths = sorted(
+        p for p in sample_images_dir.glob("*")
+        if p.suffix.lower() in {".jpg", ".jpeg", ".png", ".bmp", ".webp"}
+    ) if sample_images_dir.exists() else []
+    sample_gallery_items = [(str(p), p.name) for p in sample_image_paths]
+    sample_gt_map = _load_sample_ground_truth_map(sample_images_dir / "metadata.json")
     initial_history_choices = _history_choices(limit=100)
     initial_history_value = initial_history_choices[0][1] if initial_history_choices else None
     show_apuana_tab = _should_show_apuana_tab()
@@ -1593,12 +1674,93 @@ def create_app():
                                 label="Upload Image",
                                 type="pil"
                             )
+                            if sample_gallery_items:
+                                gr.Markdown("**Or choose a sample image:**")
+                                sample_gallery_attack = gr.Gallery(
+                                    value=sample_gallery_items,
+                                    label="Sample Image Carousel (click to select)",
+                                    columns=min(6, max(1, len(sample_gallery_items))),
+                                    rows=1,
+                                    object_fit="contain",
+                                    height=180,
+                                    allow_preview=False,
+                                )
+                            else:
+                                sample_gallery_attack = None
+                                gr.Markdown("_No sample images found in data/sample_images._")
+
+                            ground_truth_dropdown = gr.Dropdown(
+                                choices=[],
+                                value=None,
+                                multiselect=False,
+                                filterable=True,
+                                interactive=True,
+                                visible=False,
+                                label="Ground Truth Label",
+                                info="Visible only when model classes are available. Supports search.",
+                            )
+
+                            ground_truth_values_state = gr.State([])
 
                     model_select_attack.change(
                         fn=toggle_model_upload,
                         inputs=[model_select_attack],
                         outputs=[model_upload_attack]
                     )
+
+                    def refresh_ground_truth_dropdown(model_file, model_selection):
+                        model_path = _get_model_path_from_selection(model_selection, model_file)
+                        if model_path is None:
+                            return gr.update(visible=False, choices=[], value=None), []
+                        try:
+                            _, class_names, _, _ = load_model_and_labels(model_path, None, device=DEVICE)
+                        except Exception:
+                            return gr.update(visible=False, choices=[], value=None), []
+
+                        choices = _build_ground_truth_choices(class_names)
+                        values = [v for _, v in choices]
+                        if not choices:
+                            return gr.update(visible=False, choices=[], value=None), []
+                        return gr.update(visible=True, choices=choices, value=None), values
+
+                    model_select_attack.change(
+                        fn=refresh_ground_truth_dropdown,
+                        inputs=[model_upload_attack, model_select_attack],
+                        outputs=[ground_truth_dropdown, ground_truth_values_state],
+                    )
+
+                    model_upload_attack.change(
+                        fn=refresh_ground_truth_dropdown,
+                        inputs=[model_upload_attack, model_select_attack],
+                        outputs=[ground_truth_dropdown, ground_truth_values_state],
+                    )
+
+                    app.load(
+                        fn=refresh_ground_truth_dropdown,
+                        inputs=[model_upload_attack, model_select_attack],
+                        outputs=[ground_truth_dropdown, ground_truth_values_state],
+                    )
+
+                    if sample_gallery_attack is not None:
+                        def select_sample_image_for_attack(valid_values, evt: gr.SelectData):
+                            idx = evt.index
+                            if isinstance(idx, (tuple, list)):
+                                idx = idx[0] if idx else 0
+                            try:
+                                selected = sample_image_paths[int(idx)]
+                                gt_idx = sample_gt_map.get(selected.name)
+                                gt_update = None
+                                if gt_idx is not None and str(gt_idx) in set(valid_values or []):
+                                    gt_update = str(gt_idx)
+                                return Image.open(selected).convert("RGB"), gr.update(value=gt_update)
+                            except Exception:
+                                return None, gr.update()
+
+                        sample_gallery_attack.select(
+                            fn=select_sample_image_for_attack,
+                            inputs=[ground_truth_values_state],
+                            outputs=[image_upload_attack, ground_truth_dropdown],
+                        )
                     gr.Markdown("---")
 
                     # Attack Configuration Row
@@ -1916,7 +2078,7 @@ def create_app():
                     inputs=[
                         model_upload_attack, model_select_attack, image_upload_attack,
                         attack_type, eps_input, alpha_input, steps_input, decay_input, vit_weight_slider,
-                        metrics_selector
+                        metrics_selector, ground_truth_dropdown
                     ],
                     outputs=[iteration_images_state, output_text_attack, cached_attentions_state]
                 ).then(
@@ -2088,273 +2250,273 @@ def create_app():
                 with gr.Tab("Apuana Cluster"):
                     gr.Markdown("### Configure experiments and submit jobs to Apuana via SSH")
 
-                apuana_bundle_state = gr.State({})
-
-                with gr.Row():
-                    with gr.Column(scale=1):
-                        remote_user = gr.Textbox(label="Remote User", placeholder="seu_login_cin")
-                        remote_host = gr.Textbox(label="Remote Host", value=APUANA_DEFAULT_HOST)
-                        remote_project_dir = gr.Textbox(label="Remote Project Dir", value="~/ViTViz")
-                        remote_base_dir = gr.Textbox(label="Remote Jobs Base Dir", value="~/vitviz_jobs")
-                        env_activate = gr.Textbox(label="Env Activate Script", value="$HOME/ViTViz/.venv/bin/activate")
-                        python_module = gr.Textbox(label="Python Module", value="Python3.10")
-
-                    with gr.Column(scale=1):
-                        config_mode = gr.Radio(
-                            choices=["Use Config File", "Build in UI"],
-                            value="Use Config File",
-                            label="Config Source",
-                        )
-                        config_file_group = gr.Group(visible=True)
-                        with config_file_group:
-                            experiment_config = gr.Dropdown(
-                                choices=cluster_experiment_choices,
-                                value=default_cluster_config,
-                                label="Experiment Config (local)",
-                            )
-
-                        job_name = gr.Textbox(label="Job Name", value="vitviz_sweep")
-                        partition = gr.Dropdown(choices=APUANA_PARTITIONS, value="short-simple", label="Partition")
-                        qos_note = gr.Markdown(value="QoS auto: `simple`")
-
-                    with gr.Column(scale=1):
-                        cpus = gr.Slider(1, 48, value=8, step=1, label="CPUs per task")
-                        mem = gr.Textbox(label="Memory", value="16G")
-                        gpus = gr.Slider(0, 4, value=1, step=1, label="GPUs")
-                        time_limit = gr.Textbox(label="Time Limit", value="02:00:00")
-
-                config_builder_group = gr.Group(visible=False)
-                with config_builder_group:
-                    gr.Markdown("#### Dynamic Experiment Builder")
+                    apuana_bundle_state = gr.State({})
+    
                     with gr.Row():
                         with gr.Column(scale=1):
-                            selected_default_models = gr.Dropdown(
-                                choices=default_model_catalog,
-                                value=default_model_catalog,
-                                multiselect=True,
-                                label="Default Models",
-                            )
-                            custom_models_raw = gr.Textbox(
-                                label="Custom Models (one per line)",
-                                lines=5,
-                                placeholder="name|path|img_size|num_classes|type|dataset",
-                                info="Required fields: name|path. Optional fields use defaults.",
-                            )
+                            remote_user = gr.Textbox(label="Remote User", placeholder="seu_login_cin")
+                            remote_host = gr.Textbox(label="Remote Host", value=APUANA_DEFAULT_HOST)
+                            remote_project_dir = gr.Textbox(label="Remote Project Dir", value="~/ViTViz")
+                            remote_base_dir = gr.Textbox(label="Remote Jobs Base Dir", value="~/vitviz_jobs")
+                            env_activate = gr.Textbox(label="Env Activate Script", value="$HOME/ViTViz/.venv/bin/activate")
+                            python_module = gr.Textbox(label="Python Module", value="Python3.10")
+    
                         with gr.Column(scale=1):
-                            selected_attacks = gr.Dropdown(
-                                choices=default_attack_catalog,
-                                value=default_attack_catalog,
-                                multiselect=True,
-                                label="Attacks",
-                            )
-                            eps_csv = gr.Textbox(
-                                label="Epsilons (CSV)",
-                                value=default_eps_csv,
-                                placeholder="0.00784,0.01568",
-                            )
-                            seeds_csv = gr.Textbox(
-                                label="Seeds (CSV)",
-                                value=default_seeds_csv,
-                                placeholder="42,123,456",
+                            config_mode = gr.Radio(
+                                choices=["Use Config File", "Build in UI"],
+                                value="Use Config File",
+                                label="Config Source",
                             )
+                            config_file_group = gr.Group(visible=True)
+                            with config_file_group:
+                                experiment_config = gr.Dropdown(
+                                    choices=cluster_experiment_choices,
+                                    value=default_cluster_config,
+                                    label="Experiment Config (local)",
+                                )
+    
+                            job_name = gr.Textbox(label="Job Name", value="vitviz_sweep")
+                            partition = gr.Dropdown(choices=APUANA_PARTITIONS, value="short-simple", label="Partition")
+                            qos_note = gr.Markdown(value="QoS auto: `simple`")
+    
                         with gr.Column(scale=1):
-                            selected_metrics = gr.Dropdown(
-                                choices=SWEEP_METRIC_CHOICES,
-                                value=SWEEP_METRIC_DEFAULT_SELECTION,
-                                multiselect=True,
-                                label="Metrics Included",
-                            )
-                            topk_eval = gr.Slider(1, 20, value=int(default_sweep_cfg.get("evaluation", {}).get("topk", 5)), step=1, label="Top-k")
-                            compute_lpips_eval = gr.Checkbox(
-                                value=bool(default_sweep_cfg.get("evaluation", {}).get("compute_lpips", True)),
-                                label="Compute LPIPS",
-                            )
-
+                            cpus = gr.Slider(1, 48, value=8, step=1, label="CPUs per task")
+                            mem = gr.Textbox(label="Memory", value="16G")
+                            gpus = gr.Slider(0, 4, value=1, step=1, label="GPUs")
+                            time_limit = gr.Textbox(label="Time Limit", value="02:00:00")
+    
+                    config_builder_group = gr.Group(visible=False)
+                    with config_builder_group:
+                        gr.Markdown("#### Dynamic Experiment Builder")
+                        with gr.Row():
+                            with gr.Column(scale=1):
+                                selected_default_models = gr.Dropdown(
+                                    choices=default_model_catalog,
+                                    value=default_model_catalog,
+                                    multiselect=True,
+                                    label="Default Models",
+                                )
+                                custom_models_raw = gr.Textbox(
+                                    label="Custom Models (one per line)",
+                                    lines=5,
+                                    placeholder="name|path|img_size|num_classes|type|dataset",
+                                    info="Required fields: name|path. Optional fields use defaults.",
+                                )
+                            with gr.Column(scale=1):
+                                selected_attacks = gr.Dropdown(
+                                    choices=default_attack_catalog,
+                                    value=default_attack_catalog,
+                                    multiselect=True,
+                                    label="Attacks",
+                                )
+                                eps_csv = gr.Textbox(
+                                    label="Epsilons (CSV)",
+                                    value=default_eps_csv,
+                                    placeholder="0.00784,0.01568",
+                                )
+                                seeds_csv = gr.Textbox(
+                                    label="Seeds (CSV)",
+                                    value=default_seeds_csv,
+                                    placeholder="42,123,456",
+                                )
+                            with gr.Column(scale=1):
+                                selected_metrics = gr.Dropdown(
+                                    choices=SWEEP_METRIC_CHOICES,
+                                    value=SWEEP_METRIC_DEFAULT_SELECTION,
+                                    multiselect=True,
+                                    label="Metrics Included",
+                                )
+                                topk_eval = gr.Slider(1, 20, value=int(default_sweep_cfg.get("evaluation", {}).get("topk", 5)), step=1, label="Top-k")
+                                compute_lpips_eval = gr.Checkbox(
+                                    value=bool(default_sweep_cfg.get("evaluation", {}).get("compute_lpips", True)),
+                                    label="Compute LPIPS",
+                                )
+    
+                        with gr.Row():
+                            with gr.Column(scale=1):
+                                fgsm_params_json = gr.Code(
+                                    label="FGSM params (JSON)",
+                                    value=json.dumps(attack_default_params.get("FGSM", {"eps": None}), indent=2),
+                                    language="json",
+                                    lines=8,
+                                )
+                                pgd_params_json = gr.Code(
+                                    label="PGD params (JSON)",
+                                    value=json.dumps(attack_default_params.get("PGD", {"eps": None, "alpha_ratio": 0.25, "steps": 10}), indent=2),
+                                    language="json",
+                                    lines=8,
+                                )
+                            with gr.Column(scale=1):
+                                mim_params_json = gr.Code(
+                                    label="MIM params (JSON)",
+                                    value=json.dumps(attack_default_params.get("MIM", {"eps": None, "alpha_ratio": 0.25, "steps": 10, "decay": 1.0}), indent=2),
+                                    language="json",
+                                    lines=8,
+                                )
+                                tgr_params_json = gr.Code(
+                                    label="TGR params (JSON)",
+                                    value=json.dumps(attack_default_params.get("TGR", {"eps": None, "alpha_ratio": 0.25, "steps": 10, "gamma_attn": 0.25, "gamma_qkv": 0.75, "gamma_mlp": 0.5}), indent=2),
+                                    language="json",
+                                    lines=8,
+                                )
+                            with gr.Column(scale=1):
+                                saga_params_json = gr.Code(
+                                    label="SAGA params (JSON)",
+                                    value=json.dumps(attack_default_params.get("SAGA", {"eps": None, "alpha_ratio": 0.25, "steps": 10, "cnn_backbone": None}), indent=2),
+                                    language="json",
+                                    lines=8,
+                                )
+    
+                    def toggle_apuana_config_mode(mode):
+                        use_builder = mode == "Build in UI"
+                        return (
+                            gr.update(visible=not use_builder),
+                            gr.update(visible=use_builder),
+                        )
+    
+                    def update_qos_note(partition_value):
+                        return f"QoS auto: `{_qos_from_partition(partition_value)}`"
+    
+                    partition.change(
+                        fn=update_qos_note,
+                        inputs=[partition],
+                        outputs=[qos_note],
+                    )
+    
+                    config_mode.change(
+                        fn=toggle_apuana_config_mode,
+                        inputs=[config_mode],
+                        outputs=[config_file_group, config_builder_group],
+                    )
+    
                     with gr.Row():
-                        with gr.Column(scale=1):
-                            fgsm_params_json = gr.Code(
-                                label="FGSM params (JSON)",
-                                value=json.dumps(attack_default_params.get("FGSM", {"eps": None}), indent=2),
-                                language="json",
-                                lines=8,
-                            )
-                            pgd_params_json = gr.Code(
-                                label="PGD params (JSON)",
-                                value=json.dumps(attack_default_params.get("PGD", {"eps": None, "alpha_ratio": 0.25, "steps": 10}), indent=2),
-                                language="json",
-                                lines=8,
-                            )
-                        with gr.Column(scale=1):
-                            mim_params_json = gr.Code(
-                                label="MIM params (JSON)",
-                                value=json.dumps(attack_default_params.get("MIM", {"eps": None, "alpha_ratio": 0.25, "steps": 10, "decay": 1.0}), indent=2),
-                                language="json",
-                                lines=8,
-                            )
-                            tgr_params_json = gr.Code(
-                                label="TGR params (JSON)",
-                                value=json.dumps(attack_default_params.get("TGR", {"eps": None, "alpha_ratio": 0.25, "steps": 10, "gamma_attn": 0.25, "gamma_qkv": 0.75, "gamma_mlp": 0.5}), indent=2),
-                                language="json",
-                                lines=8,
-                            )
-                        with gr.Column(scale=1):
-                            saga_params_json = gr.Code(
-                                label="SAGA params (JSON)",
-                                value=json.dumps(attack_default_params.get("SAGA", {"eps": None, "alpha_ratio": 0.25, "steps": 10, "cnn_backbone": None}), indent=2),
-                                language="json",
-                                lines=8,
-                            )
-
-                def toggle_apuana_config_mode(mode):
-                    use_builder = mode == "Build in UI"
-                    return (
-                        gr.update(visible=not use_builder),
-                        gr.update(visible=use_builder),
+                        btn_generate = gr.Button("1) Generate Bundle", variant="secondary")
+                        btn_sync = gr.Button("2) Sync Bundle", variant="secondary")
+                        btn_submit = gr.Button("3) Submit Job", variant="primary")
+    
+                    gr.Markdown("#### Saved Bundle History")
+                    with gr.Row():
+                        bundle_history = gr.Dropdown(
+                            label="Saved Bundles",
+                            choices=initial_history_choices,
+                            value=initial_history_value,
+                            allow_custom_value=False,
+                        )
+                    with gr.Row():
+                        btn_refresh_history = gr.Button("Refresh History", variant="secondary")
+                        btn_load_selected = gr.Button("Load Selected Bundle", variant="secondary")
+                        btn_load_last = gr.Button("Load Last Bundle", variant="secondary")
+    
+                    with gr.Row():
+                        job_id_box = gr.Textbox(label="Job ID", placeholder="Preenchido apos submissao ou manual")
+                        btn_status = gr.Button("Check Job Status")
+                        btn_queue = gr.Button("List My Queue")
+                        btn_logs = gr.Button("Check Last Job Logs")
+                        btn_cancel = gr.Button("Cancel Job")
+    
+                    gr.Markdown("#### Optional: Download remote outputs")
+                    with gr.Row():
+                        remote_download_path = gr.Textbox(label="Remote Path", placeholder="~/vitviz_jobs/.../logs/")
+                        local_download_path = gr.Textbox(label="Local Destination", value="results/raw/apuana_downloads")
+                        btn_download = gr.Button("Download via rsync")
+    
+                    apuana_output = gr.Markdown(value="Ready to configure Apuana job.")
+    
+                    btn_generate.click(
+                        fn=apuana_generate_bundle,
+                        inputs=[
+                            remote_user,
+                            remote_host,
+                            remote_project_dir,
+                            remote_base_dir,
+                            env_activate,
+                            python_module,
+                            config_mode,
+                            experiment_config,
+                            job_name,
+                            partition,
+                            cpus,
+                            mem,
+                            gpus,
+                            time_limit,
+                            selected_default_models,
+                            custom_models_raw,
+                            selected_attacks,
+                            fgsm_params_json,
+                            pgd_params_json,
+                            mim_params_json,
+                            tgr_params_json,
+                            saga_params_json,
+                            eps_csv,
+                            seeds_csv,
+                            selected_metrics,
+                            topk_eval,
+                            compute_lpips_eval,
+                        ],
+                        outputs=[apuana_output, apuana_bundle_state],
                     )
-
-                def update_qos_note(partition_value):
-                    return f"QoS auto: `{_qos_from_partition(partition_value)}`"
-
-                partition.change(
-                    fn=update_qos_note,
-                    inputs=[partition],
-                    outputs=[qos_note],
-                )
-
-                config_mode.change(
-                    fn=toggle_apuana_config_mode,
-                    inputs=[config_mode],
-                    outputs=[config_file_group, config_builder_group],
-                )
-
-                with gr.Row():
-                    btn_generate = gr.Button("1) Generate Bundle", variant="secondary")
-                    btn_sync = gr.Button("2) Sync Bundle", variant="secondary")
-                    btn_submit = gr.Button("3) Submit Job", variant="primary")
-
-                gr.Markdown("#### Saved Bundle History")
-                with gr.Row():
-                    bundle_history = gr.Dropdown(
-                        label="Saved Bundles",
-                        choices=initial_history_choices,
-                        value=initial_history_value,
-                        allow_custom_value=False,
+    
+                    btn_sync.click(
+                        fn=apuana_sync_bundle,
+                        inputs=[remote_user, remote_host, apuana_bundle_state],
+                        outputs=[apuana_output],
+                    )
+    
+                    btn_submit.click(
+                        fn=apuana_submit_bundle,
+                        inputs=[remote_user, remote_host, apuana_bundle_state],
+                        outputs=[apuana_output, job_id_box],
+                    )
+    
+                    btn_status.click(
+                        fn=apuana_check_job,
+                        inputs=[remote_user, remote_host, job_id_box],
+                        outputs=[apuana_output],
+                    )
+    
+                    btn_queue.click(
+                        fn=apuana_list_jobs,
+                        inputs=[remote_user, remote_host],
+                        outputs=[apuana_output],
+                    )
+    
+                    btn_logs.click(
+                        fn=apuana_check_last_logs,
+                        inputs=[remote_user, remote_host, apuana_bundle_state, job_id_box],
+                        outputs=[apuana_output],
+                    )
+    
+                    btn_cancel.click(
+                        fn=apuana_cancel,
+                        inputs=[remote_user, remote_host, job_id_box],
+                        outputs=[apuana_output],
+                    )
+    
+                    btn_download.click(
+                        fn=apuana_download_results,
+                        inputs=[remote_user, remote_host, remote_download_path, local_download_path],
+                        outputs=[apuana_output],
+                    )
+    
+                    btn_refresh_history.click(
+                        fn=apuana_refresh_history,
+                        inputs=[],
+                        outputs=[apuana_output, bundle_history],
                     )
-                with gr.Row():
-                    btn_refresh_history = gr.Button("Refresh History", variant="secondary")
-                    btn_load_selected = gr.Button("Load Selected Bundle", variant="secondary")
-                    btn_load_last = gr.Button("Load Last Bundle", variant="secondary")
-
-                with gr.Row():
-                    job_id_box = gr.Textbox(label="Job ID", placeholder="Preenchido apos submissao ou manual")
-                    btn_status = gr.Button("Check Job Status")
-                    btn_queue = gr.Button("List My Queue")
-                    btn_logs = gr.Button("Check Last Job Logs")
-                    btn_cancel = gr.Button("Cancel Job")
-
-                gr.Markdown("#### Optional: Download remote outputs")
-                with gr.Row():
-                    remote_download_path = gr.Textbox(label="Remote Path", placeholder="~/vitviz_jobs/.../logs/")
-                    local_download_path = gr.Textbox(label="Local Destination", value="results/raw/apuana_downloads")
-                    btn_download = gr.Button("Download via rsync")
-
-                apuana_output = gr.Markdown(value="Ready to configure Apuana job.")
-
-                btn_generate.click(
-                    fn=apuana_generate_bundle,
-                    inputs=[
-                        remote_user,
-                        remote_host,
-                        remote_project_dir,
-                        remote_base_dir,
-                        env_activate,
-                        python_module,
-                        config_mode,
-                        experiment_config,
-                        job_name,
-                        partition,
-                        cpus,
-                        mem,
-                        gpus,
-                        time_limit,
-                        selected_default_models,
-                        custom_models_raw,
-                        selected_attacks,
-                        fgsm_params_json,
-                        pgd_params_json,
-                        mim_params_json,
-                        tgr_params_json,
-                        saga_params_json,
-                        eps_csv,
-                        seeds_csv,
-                        selected_metrics,
-                        topk_eval,
-                        compute_lpips_eval,
-                    ],
-                    outputs=[apuana_output, apuana_bundle_state],
-                )
-
-                btn_sync.click(
-                    fn=apuana_sync_bundle,
-                    inputs=[remote_user, remote_host, apuana_bundle_state],
-                    outputs=[apuana_output],
-                )
-
-                btn_submit.click(
-                    fn=apuana_submit_bundle,
-                    inputs=[remote_user, remote_host, apuana_bundle_state],
-                    outputs=[apuana_output, job_id_box],
-                )
-
-                btn_status.click(
-                    fn=apuana_check_job,
-                    inputs=[remote_user, remote_host, job_id_box],
-                    outputs=[apuana_output],
-                )
-
-                btn_queue.click(
-                    fn=apuana_list_jobs,
-                    inputs=[remote_user, remote_host],
-                    outputs=[apuana_output],
-                )
-
-                btn_logs.click(
-                    fn=apuana_check_last_logs,
-                    inputs=[remote_user, remote_host, apuana_bundle_state, job_id_box],
-                    outputs=[apuana_output],
-                )
-
-                btn_cancel.click(
-                    fn=apuana_cancel,
-                    inputs=[remote_user, remote_host, job_id_box],
-                    outputs=[apuana_output],
-                )
-
-                btn_download.click(
-                    fn=apuana_download_results,
-                    inputs=[remote_user, remote_host, remote_download_path, local_download_path],
-                    outputs=[apuana_output],
-                )
-
-                btn_refresh_history.click(
-                    fn=apuana_refresh_history,
-                    inputs=[],
-                    outputs=[apuana_output, bundle_history],
-                )
-
-                btn_load_selected.click(
-                    fn=apuana_load_selected_bundle,
-                    inputs=[bundle_history],
-                    outputs=[apuana_output, apuana_bundle_state, job_id_box, remote_download_path, bundle_history],
-                )
-
-                btn_load_last.click(
-                    fn=apuana_load_last_bundle,
-                    inputs=[],
-                    outputs=[apuana_output, apuana_bundle_state, job_id_box, remote_download_path, bundle_history],
-                )
-            
     
+                    btn_load_selected.click(
+                        fn=apuana_load_selected_bundle,
+                        inputs=[bundle_history],
+                        outputs=[apuana_output, apuana_bundle_state, job_id_box, remote_download_path, bundle_history],
+                    )
+    
+                    btn_load_last.click(
+                        fn=apuana_load_last_bundle,
+                        inputs=[],
+                        outputs=[apuana_output, apuana_bundle_state, job_id_box, remote_download_path, bundle_history],
+                    )
+                
+        
     return app
 
 if __name__ == "__main__":
@@ -2368,4 +2530,4 @@ if __name__ == "__main__":
         )
 
     except KeyboardInterrupt:
-        print("\nShutting down gracefully...")
+        print("\nShutting down gracefully...")

experiments/run_attack_sweep.py

@@ -20,6 +20,7 @@ Usage:
 
 import argparse
 import csv
+import json
 import os
 import sys
 import time
@@ -137,7 +138,7 @@ def create_attack(model, attack_cfg: dict, eps: float):
 
 CSV_COLUMNS = [
     "model", "attack", "epsilon", "seed", "image",
-    "orig_pred", "orig_conf", "adv_pred", "adv_conf",
+    "orig_pred", "orig_conf", "adv_pred", "adv_conf", "ground_truth",
     # Attack success
     "asr", "confidence_drop", "topk_drop",
     # Image quality
@@ -155,6 +156,35 @@ ATTENTION_METRIC_COLUMNS = [
 ]
 
 
+def load_sample_ground_truth_map(sample_dir: Path) -> dict[str, int]:
+    """Load sample filename -> class index mapping from metadata.json (if present)."""
+    metadata_path = sample_dir / "metadata.json"
+    if not metadata_path.exists():
+        return {}
+
+    try:
+        with open(metadata_path, "r", encoding="utf-8") as f:
+            payload = json.load(f) or {}
+    except Exception:
+        return {}
+
+    files = payload.get("downloaded_files") or []
+    classes = payload.get("suggested_classes") or []
+    n = min(len(files), len(classes))
+    mapping: dict[str, int] = {}
+    for i in range(n):
+        filename = str(files[i]).strip()
+        cls = classes[i] if isinstance(classes[i], dict) else {}
+        cls_id = cls.get("imagenet_id")
+        if not filename:
+            continue
+        try:
+            mapping[filename] = int(cls_id)
+        except (TypeError, ValueError):
+            continue
+    return mapping
+
+
 # ═══════════════════════════════════════════════════════════════════════════
 # Main sweep
 # ═══════════════════════════════════════════════════════════════════════════
@@ -209,6 +239,7 @@ def run_single(
     img_path: Path, device: torch.device,
     eval_cfg: dict, attn_cfg: dict,
     selected_metrics: set,
+    sample_gt_map: dict[str, int],
 ) -> dict:
     """Run a single attack and compute all metrics. Returns a dict row."""
     set_seed(seed)
@@ -257,12 +288,14 @@ def run_single(
 
     # Attack success metrics (compute only when selected; keep fixed CSV schema)
     atk_metrics = {k: float("nan") for k in ATTACK_METRIC_COLUMNS}
+    ground_truth = sample_gt_map.get(img_path.name)
     if selected_metrics.intersection(ATTACK_METRIC_COLUMNS):
         raw_atk_metrics = compute_all_attack_metrics(
             orig_probs,
             adv_probs,
             orig_pred,
             adv_pred,
+            ground_truth=ground_truth,
             k=eval_cfg.get("topk", 5),
         )
         for k in ATTACK_METRIC_COLUMNS:
@@ -303,6 +336,7 @@ def run_single(
         "orig_conf": f"{orig_conf:.6f}",
         "adv_pred": str(adv_pred),
         "adv_conf": f"{adv_conf:.6f}",
+        "ground_truth": "" if ground_truth is None else str(ground_truth),
         **{k: ("" if np.isnan(v) else f"{v:.6f}") for k, v in atk_metrics.items()},
         **{k: ("" if np.isnan(v) else f"{v:.6f}") for k, v in img_metrics.items()},
         **{k: ("" if np.isnan(v) else f"{v:.6f}") for k, v in attn_metrics.items()},
@@ -335,6 +369,7 @@ def main():
     results_dir = Path(config["output"]["results_dir"])
     results_dir.mkdir(parents=True, exist_ok=True)
     images_dir = Path(config["data"]["images_dir"])
+    sample_gt_map = load_sample_ground_truth_map(images_dir)
 
     if not images_dir.exists():
         images_dir.mkdir(parents=True, exist_ok=True)
@@ -426,6 +461,7 @@ def main():
                 attack_cfg_copy, eps, seed, img_path, device,
                 config["evaluation"], config.get("attention", {}),
                 selected_metrics,
+                sample_gt_map,
             )
 
             # Append to CSV

utils/metrics.py

@@ -259,42 +259,42 @@ def compute_modified_pixels(orig: torch.Tensor, adv: torch.Tensor,
 # Attack Success Metrics
 # ═══════════════════════════════════════════════════════════════════════════
 
-def compute_asr(orig_pred: int, adv_pred: int) -> float:
+def compute_asr(reference_label: int, adv_pred: int) -> float:
     """Attack Success Rate for a single sample.
 
-    Returns 1.0 if attack changed the prediction, 0.0 otherwise.
+    Returns 1.0 if attack prediction differs from the reference label, 0.0 otherwise.
     For batch ASR, average across samples.
     """
-    return 1.0 if orig_pred != adv_pred else 0.0
+    return 1.0 if reference_label != adv_pred else 0.0
 
 
 def compute_confidence_drop(orig_probs: torch.Tensor,
                             adv_probs: torch.Tensor,
-                            orig_label: int) -> float:
-    """Confidence drop on the original class.
+                            reference_label: int) -> float:
+    """Confidence drop on a reference class.
 
     Args:
         orig_probs: Softmax probabilities for original image (1D tensor).
         adv_probs:  Softmax probabilities for adversarial image (1D tensor).
-        orig_label: Original predicted class index.
+        reference_label: Reference class index (ground truth when available).
 
     Returns:
         Drop in confidence (positive = confidence decreased).
     """
-    return (orig_probs[orig_label] - adv_probs[orig_label]).item()
+    return (orig_probs[reference_label] - adv_probs[reference_label]).item()
 
 
 def compute_topk_drop(orig_probs: torch.Tensor,
                       adv_probs: torch.Tensor,
-                      orig_label: int,
+                      reference_label: int,
                       k: int = 5) -> float:
     """Top-k accuracy drop.
 
-    Checks if original class remains in top-k predictions after attack.
-    Returns 1.0 if original class dropped out of top-k, 0.0 if still in.
+    Checks if reference class remains in top-k predictions after attack.
+    Returns 1.0 if reference class dropped out of top-k, 0.0 if still in.
     """
     _, adv_topk = torch.topk(adv_probs, min(k, len(adv_probs)))
-    return 0.0 if orig_label in adv_topk.tolist() else 1.0
+    return 0.0 if reference_label in adv_topk.tolist() else 1.0
 
 
 
@@ -341,17 +341,22 @@ def compute_all_attack_metrics(
     adv_probs: torch.Tensor,
     orig_label: int,
     adv_label: int,
+    ground_truth: Optional[int] = None,
     k: int = 5,
 ) -> Dict[str, float]:
     """Compute all attack success metrics at once.
 
+    If ground_truth is provided, class-dependent metrics use it as reference.
+    Otherwise, the original predicted label is used (backward-compatible behavior).
+
     Returns:
         Dictionary with keys: asr, confidence_drop, topk_drop.
     """
+    ref_label = int(ground_truth) if ground_truth is not None else int(orig_label)
     results = {
-        "asr": compute_asr(orig_label, adv_label),
-        "confidence_drop": compute_confidence_drop(orig_probs, adv_probs, orig_label),
-        "topk_drop": compute_topk_drop(orig_probs, adv_probs, orig_label, k=k),
+        "asr": compute_asr(ref_label, adv_label),
+        "confidence_drop": compute_confidence_drop(orig_probs, adv_probs, ref_label),
+        "topk_drop": compute_topk_drop(orig_probs, adv_probs, ref_label, k=k),
     }
 
     return results