git commit -m "feat: expand ViTViz with experiment pipeline, metrics module, model loading improvements and report UX" -m "- add experiment infrastructure with configs, sweep scripts, notebooks and Makefile tasks

add metrics and seed utility modules and wire metrics into attack reporting
improve Hugging Face model loading to support timm wrapper checkpoints
update adversarial attacks for iterative artifact capture and robustness fixes
enhance UI/report with metric tooltips, metric selection control, and layout refinements
update docs, dependencies and repository ignore rules"

.gitignore

@@ -205,3 +205,26 @@ cython_debug/
 marimo/_static/
 marimo/_lsp/
 __marimo__/
+
+# Paper (editado no Overleaf, não versionado aqui)
+paper/
+
+# Gradio cache (gerado automaticamente)
+.gradio/
+
+# ViTViz experiment outputs
+results/raw/
+results/figures/
+results/tables/
+*.npy
+data/sample_images/*.jpg
+data/sample_images/*.jpeg
+data/sample_images/*.png
+data/sample_images/*.JPEG
+!data/sample_images/.gitkeep
+
+# Model files
+models/*.pth
+models/*.pt
+models/*.safetensors
+models/*.ckpt

Makefile

@@ -0,0 +1,35 @@
+.PHONY: install app experiment attention figures clean help
+
+PYTHON ?= python
+CONFIG ?= configs/default.yaml
+
+help: ## Show this help
+	@grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | awk 'BEGIN {FS = ":.*?## "}; {printf "  \033[36m%-18s\033[0m %s\n", $$1, $$2}'
+
+install: ## Install all dependencies
+	pip install -r requirements.txt
+
+download-samples: ## Download 10 sample ImageNet images (requer HF login)
+	$(PYTHON) data/download_samples.py
+
+app: ## Run the Gradio web app
+	$(PYTHON) app.py
+
+experiment: ## Run full attack sweep (CONFIG=configs/experiments/exp_quick_test.yaml)
+	$(PYTHON) experiments/run_attack_sweep.py --config $(CONFIG)
+
+experiment-dry: ## Dry run: show combinations without running attacks
+	$(PYTHON) experiments/run_attack_sweep.py --config $(CONFIG) --dry-run
+
+attention: ## Run attention analysis for all config combinations
+	$(PYTHON) experiments/run_attention_analysis.py --config $(CONFIG) --all
+
+quick-test: ## Run quick experiment (single model, FGSM, 1 epsilon)
+	$(PYTHON) experiments/run_attack_sweep.py --config configs/experiments/exp_quick_test.yaml
+
+clean-results: ## Remove all experiment outputs
+	rm -rf results/raw/ results/figures/ results/tables/
+
+clean: clean-results ## Clean all generated files
+	find . -type d -name __pycache__ -exec rm -rf {} + 2>/dev/null || true
+	find . -name "*.pyc" -delete 2>/dev/null || true

Métricas para avaliação no ViT-Viz.txt

@@ -0,0 +1,78 @@
+Métricas para avaliação no ViT-Viz
+
+
+1) Métricas de qualidade de imagem
+ℓ_∞ (perturbação máxima)
+* O que mede: alteração máxima em qualquer pixel.
+* Relevância: Essencial
+
+
+ℓ_2 (distância euclidiana)
+* O que mede: energia total da perturbação, muitos pixels pouco alterados vs poucos pixels muito alterados.
+* Relevância: complementa ℓ_∞.
+
+
+PSNR (Peak Signal-to-Noise Ratio)
+* O que mede: similaridade a nível de pixel via MSE.
+* Relevância: Alta, legal para medir fidelidade pixel-wise para um mesmo ASR por exemplo.
+
+
+SSIM (Structural Similarity Index)
+* O que mede: similaridade estrutural, padrões locais, mais alinhada à percepção humana que PSNR.
+* Relevância: Alta, simples implementação e é interpretável 
+
+
+MS-SSIM (Multi-Scale SSIM)
+* O que mede: similaridade estrutural, mas dessa vez focando em diferentes níveis de detalhe (macroestrutura vs microtextura)
+* Relevância: Baixa, parece muito específico.
+
+
+LPIPS (Learned Perceptual Image Patch Similarity)
+* O que mede: diferênça semântica local aproximada
+* Relevância: Essencial, acho que faz muito sentido quando estamos tentando ver perturbações na atenção.
+NIQE/BRISQUE
+* O que mede: naturalidade da imagem, sem usar referência, são baseadas em estatísticas de cenas naturais.
+* Relevância: baixa, acho que pode ser mais exploratório.
+* NIQE (Mittal et al., 2013).
+* BRISQUE (Mittal et al., 2012).
+
+
+FID (Fréchet Inception Distance)
+* O que mede: é uma métrica mais global que analisa mudança do conjunto adversarial em relação ao conjunto limpo usando espaço de features do Inception
+* Relevância: Baixa, mas acho que pode ser legal para uma análise global e é recente (Heusel et al. 2017.), mas é pesado computacionalmente.
+
+
+2) Métricas de sucesso de ataque
+ASR
+* O que mede: taxa de sucesso do ataque em mudar a decisão.
+* Relevância: essencial.
+
+
+Top-K accuracy drop’
+* O que mede: se o ataque só tira a label certa do top-1 ou se ataca o top-k.
+* Relevância: alta, é simples e informativa.
+
+
+Confidence drop
+* O que mede: queda de confiança do modelo em suas classificações.
+* Relevância: Essencial.
+
+
+
+
+3) Outras métricas úteis
+Logit margin
+* O que mede: Quão perto o exemplo ficou da fronteira de decisão em espaço de logits.
+* Relevância: baixa-média, acho complementar a outras métricas
+4) Métricas específicas de atenção
+
+
+Divergências Kullback-Leibler e/ou Jensen-Shannon entre mapas de attention ou attention rollout
+* O que mede: diferença distribucional entre os dois padrões de atenção (antes vs depois do ataque), ou seja, o quanto a “massa” de atenção foi redistribuída pelos tokens/patches.
+* Relevância: Alta, permite quantificar bem a mudança de atenção se tratarmos os mapas como distribuições de probabilidade.
+* Obs: JS lida melhor com valores próximos de zero, possivelmente descarta KL. Importante se ligar nas normalizações necessárias quando utilizar esse tipo de métrica.
+
+
+Similaridade de cossenos
+* O que mede: mudança do vetor de atenção.
+* Relevância: Essencial, é mais simples e também quantifica bem a mudança nos attention maps.

README.md

@@ -25,9 +25,10 @@ Any timm-compatible ViT architecture (`model.blocks[i].attn.qkv`), including:
 
 | Model | Architecture | Dataset |
 |-------|-------------|---------|
-| ViT-B/16 | Base, patch 16 | Stanford40 Actions |
+| ViT-B/16 | Base, patch 16 | ImageNet-1k |
 | ViT-B/32 | Base, patch 32, 384px | ImageNet-1k |
 | ViT-L/16 | Large, patch 16 | ImageNet-1k |
+| ViT-L/32 | Large, patch 32, 384px | ImageNet-1k |
 | DeiT-S/16 | Small, patch 16 | ImageNet-1k |
 | Custom Upload | Any ViT | Any |
 
@@ -35,9 +36,77 @@ Any timm-compatible ViT architecture (`model.blocks[i].attn.qkv`), including:
 
 `.pth`, `.pt`, `.safetensors`, `.ckpt`
 
-## Running Locally
+## Quick Start
 
 ```bash
-pip install -r requirements.txt
-python app.py
+# 1. Clone e instale as dependências
+git clone <repo-url>
+cd ViTViz
+make install
+
+# 2. Suba o app Gradio
+make app
 ```
+
+## Comandos Disponíveis (`make help`)
+
+| Comando | Descrição |
+|---|---|
+| `make install` | Instala todas as dependências |
+| `make app` | Roda o app Gradio (`localhost:7860`) |
+| `make quick-test` | Teste rápido: DeiT-S + FGSM + 1 epsilon |
+| `make experiment` | Sweep completo de ataques (config padrão) |
+| `make experiment-dry` | Mostra combinações sem executar nada |
+| `make attention` | Gera mapas de atenção para todas as combinações |
+| `make clean` | Remove resultados e cache |
+
+Para usar um config específico:
+
+```bash
+make experiment CONFIG=configs/experiments/exp_all_attacks.yaml
+```
+
+## Pipeline de Experimentos
+
+O projeto expõe um pipeline de linha de comando separado da UI, voltado para geração de resultados reproduzíveis para artigos científicos.
+
+### Estrutura de diretórios
+
+```
+configs/                  # Configurações YAML de experimentos
+  default.yaml            # Config base (modelos, ataques, epsilons, seeds)
+  experiments/
+    exp_quick_test.yaml   # Teste rápido (1 modelo, 1 ataque)
+    exp_all_attacks.yaml  # Sweep completo
+data/
+  sample_images/          # Imagens de entrada (.jpg/.png)
+experiments/
+  run_attack_sweep.py     # Sweep de ataques → CSV com métricas
+  run_attention_analysis.py  # Salva rollouts de atenção (.npy + .png)
+notebooks/
+  01-metrics-analysis.ipynb  # Gera tabelas LaTeX e gráficos de métricas
+  02-attention-figures.ipynb # Gera figuras de comparação de atenção
+results/
+  raw/                    # Outputs brutos (CSV, .npy, imagens)
+  figures/                # Figuras geradas pelos notebooks
+  tables/                 # Tabelas LaTeX
+```
+
+### Workflow para paper
+
+```bash
+# 1. Adicione imagens em data/sample_images/
+# 2. Rode os experimentos
+make experiment
+
+# 3. Gere os mapas de atenção
+make attention
+
+# 4. Abra os notebooks para gerar figuras e tabelas
+cd notebooks && jupyter notebook
+```
+
+### Métricas calculadas automaticamente
+
+- **Perturbação**: L∞, L₂, PSNR, SSIM, LPIPS, Modified Pixels  
+- **Ataque**: ASR, Confidence Drop, Top-k Overlap Drop

app.py

@@ -1,5 +1,6 @@
 import gradio as gr
 import os
+import html
 import numpy as np
 import torch
 from PIL import Image
@@ -10,6 +11,10 @@ from utils.model_loader import load_model_and_labels, ViTConfig
 from utils.preprocessing import get_default_transform, preprocess_image
 from utils.inference import predict_topk
 from utils.attacks import PGDIterations, FGSM, SAGA, MIFGSM, TGR
+from utils.metrics import (
+    compute_linf, compute_psnr, compute_ssim, compute_lpips,
+    compute_modified_pixels, compute_confidence_drop, compute_topk_drop,
+)
 from utils.visualization import (
     extract_attention_maps,
     attention_rollout,
@@ -34,19 +39,31 @@ ICON_GEAR = '<i class="bi bi-gear-fill vitviz-bi" aria-hidden="true"></i>'
 
 # Backbone CNN opcional usado no modo "SAGA (with CNN gradient)".
 # Pode ser um caminho local (ex.: "models/resnet.pth") ou um checkpoint no Hugging Face Hub.
-RESNET_BACKBONE_SPEC = "hf://lucasddmc/resnet101-stanford40-actions/resnet.pth"
+RESNET_BACKBONE_SPEC = None
 
 # Modelos pré-configurados disponíveis para seleção
 # Diversas arquiteturas para demonstrar flexibilidade do projeto
 AVAILABLE_MODELS = {
-    "ViT-B/16 · Stanford40 Actions": "hf-model://lucasddmc/vit-b16-stanford40-actions",
+    "ViT-B/16 · ImageNet-1k": "hf-model://google/vit-base-patch16-224",
     "ViT-B/32 · ImageNet-1k (384px)": "hf-model://google/vit-base-patch32-384",
     "ViT-L/16 · ImageNet-1k": "hf-model://google/vit-large-patch16-224",
+    "ViT-L/32 · ImageNet-1k (384px)": "hf-model://google/vit-large-patch32-384",
     "DeiT-S/16 · ImageNet-1k": "hf-model://facebook/deit-small-patch16-224",
     "Custom Upload": None,  # Sinaliza que o usuário deve fazer upload
 }
 MODEL_CHOICES = list(AVAILABLE_MODELS.keys())
-DEFAULT_MODEL = MODEL_CHOICES[0]  # Stanford40 por padrão
+DEFAULT_MODEL = MODEL_CHOICES[0]  # ImageNet-1k por padrão
+
+METRIC_OPTIONS = [
+    "L∞ Distance",
+    "PSNR",
+    "SSIM",
+    "LPIPS",
+    "Modified Pixels",
+    "Confidence Drop",
+    "Top-K Accuracy Drop",
+]
+METRIC_DROPDOWN_OPTIONS = ["Select All", *METRIC_OPTIONS]
 
 def _get_model_path_from_selection(model_selection: str, model_file) -> str:
     """Retorna o path do modelo baseado na seleção do Radio."""
@@ -236,6 +253,7 @@ def run_attack(
     steps: int,
     decay: float,
     vit_weight: float,
+    selected_metrics,
 ) -> Tuple[List[Image.Image], str, List[List[torch.Tensor]]]:
     """
     Executa ataque adversarial (FGSM ou PGD) untargeted e extrai atenção.
@@ -249,6 +267,7 @@ def run_attack(
         alpha: step size (apenas PGD/MIM)
         steps: número de iterações (iterativos)
         decay: momentum decay (apenas MIM)
+        selected_metrics: métricas selecionadas no dropdown
     
     Returns:
         (iteration_images, result_text, attention_overlays)
@@ -267,7 +286,7 @@ def run_attack(
         img_tensor = preprocess_image(image, transform=dynamic_transform).to(DEVICE)
         
         # Predição original (top-5 para comparação)
-        top_prob_orig, top_idx_orig, num_classes, _ = predict_topk(model, img_tensor, top_k=5, device=DEVICE)
+        top_prob_orig, top_idx_orig, num_classes, orig_probs_full = predict_topk(model, img_tensor, top_k=5, device=DEVICE)
         orig_class = top_idx_orig[0].item()
         orig_prob = top_prob_orig[0].item()
         
@@ -303,22 +322,58 @@ def run_attack(
         cached_attns = getattr(attack, 'attentions_per_iter', None)
         
         # Predição adversarial (top-5 para comparação)
-        top_prob_adv, top_idx_adv, _, _ = predict_topk(model, adv_tensor, top_k=5, device=DEVICE)
+        top_prob_adv, top_idx_adv, _, adv_probs_full = predict_topk(model, adv_tensor, top_k=5, device=DEVICE)
         adv_class = top_idx_adv[0].item()
         adv_prob = top_prob_adv[0].item()
+
+        # Resolver seleção de métricas:
+        # - sem seleção ou com "Select All" => mostra todas
+        # - caso contrário, mostra apenas as escolhidas
+        requested_metrics = selected_metrics or []
+        if (not requested_metrics) or ("Select All" in requested_metrics):
+            requested_metrics = METRIC_OPTIONS.copy()
+        else:
+            requested_metrics = [m for m in METRIC_OPTIONS if m in requested_metrics]
         
-        # Calcular métricas de perturbação no espaço [0,1] (desnormalizado)
-        # Isso é importante porque epsilon é definido no espaço [0,1], não no espaço normalizado
-        mean = torch.tensor([0.485, 0.456, 0.406]).view(1, 3, 1, 1).to(DEVICE)
-        std = torch.tensor([0.229, 0.224, 0.225]).view(1, 3, 1, 1).to(DEVICE)
-        
-        # Desnormalizar ambos os tensores para espaço [0,1]
-        img_denorm = img_tensor * std + mean
-        adv_denorm = adv_tensor * std + mean
-        
-        delta = (adv_denorm - img_denorm).detach()
-        l_inf = delta.abs().max().item()
-        pixels_changed = (delta.abs() > 1e-6).float().mean().item() * 100
+        # Calcular apenas métricas solicitadas
+        metric_values = {}
+        if "L∞ Distance" in requested_metrics:
+            metric_values["L∞ Distance"] = f"{compute_linf(img_tensor, adv_tensor):.6f}"
+        if "PSNR" in requested_metrics:
+            metric_values["PSNR"] = f"{compute_psnr(img_tensor, adv_tensor):.2f} dB"
+        if "SSIM" in requested_metrics:
+            metric_values["SSIM"] = f"{compute_ssim(img_tensor, adv_tensor):.4f}"
+        if "LPIPS" in requested_metrics:
+            metric_values["LPIPS"] = f"{compute_lpips(img_tensor, adv_tensor):.4f}"
+        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}"
+        if "Top-K Accuracy Drop" in requested_metrics:
+            topk_drop = compute_topk_drop(orig_probs_full, adv_probs_full, orig_class, k=5)
+            metric_values["Top-K Accuracy Drop"] = "Yes" if topk_drop >= 0.5 else "No"
+
+        metric_tooltips = {
+            "L∞ Distance": "Maximum absolute per-pixel perturbation between original and adversarial images in [0,1] space. Lower is less visible.",
+            "PSNR": "Peak Signal-to-Noise Ratio computed from MSE and expressed in dB. Higher generally indicates less distortion.",
+            "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.",
+        }
+
+        def metric_label_with_info(label: str, tooltip_text: str) -> str:
+            safe_tip = html.escape(tooltip_text, quote=True)
+            return (
+                '<span class="vitviz-metric-name">'
+                f"<b>{label}</b>"
+                '<span class="vitviz-tooltip-wrap">'
+                f'<span class="vitviz-info-icon" aria-label="{safe_tip}" tabindex="0">i</span>'
+                f'<span class="vitviz-tooltip" role="tooltip">{safe_tip}</span>'
+                '</span>'
+                "</span>"
+            )
         
         # Format result com tabela comparativa
         result = f"## {attack_type} Attack Result (Untargeted)\n\n"
@@ -392,10 +447,17 @@ def run_attack(
         result += f"  <div class=\"vitviz-panel\">\n"
         result += f"    <div class=\"vitviz-panel__title\">{ICON_RULER} Perturbation Metrics</div>\n"
         result += "    <table class=\"vitviz-table\">\n"
-        result += "      <thead><tr><th>Metric</th><th>Value</th><th>Description</th></tr></thead>\n"
+        result += "      <thead><tr><th>Metric</th><th>Value</th></tr></thead>\n"
         result += "      <tbody>\n"
-        result += f"        <tr><td><b>L∞ Distance</b></td><td>{l_inf:.6f}</td><td>Maximum pixel change</td></tr>\n"
-        result += f"        <tr><td><b>Modified Pixels</b></td><td>{pixels_changed:.1f}%</td><td>Pixels with |δ| &gt; 1e-6</td></tr>\n"
+        visible_metrics = [m for m in METRIC_OPTIONS if m in metric_values]
+        if visible_metrics:
+            for metric_name in visible_metrics:
+                result += (
+                    f"        <tr><td>{metric_label_with_info(metric_name, metric_tooltips[metric_name])}</td>"
+                    f"<td>{metric_values[metric_name]}</td></tr>\n"
+                )
+        else:
+            result += "        <tr><td colspan=\"2\"><i>No metrics selected.</i></td></tr>\n"
         result += "      </tbody>\n"
         result += "    </table>\n"
         result += "  </div>\n"
@@ -543,6 +605,7 @@ def create_app():
         border-spacing: 0;
         font-size: 13px;
         border: 1px solid rgba(255, 255, 255, 0.18);
+        overflow: visible;
     }
     .vitviz-table th,
     .vitviz-table td {
@@ -551,6 +614,7 @@ def create_app():
         border-right: 1px solid rgba(255, 255, 255, 0.10);
         vertical-align: top;
         text-align: left;
+        overflow: visible;
     }
     .vitviz-table th:last-child,
     .vitviz-table td:last-child {
@@ -563,6 +627,94 @@ def create_app():
     .vitviz-table tbody tr:last-child td {
         border-bottom: none;
     }
+    .vitviz-metric-name {
+        display: inline-flex;
+        align-items: center;
+        gap: 8px;
+    }
+    .vitviz-tooltip-wrap {
+        position: relative;
+        display: inline-flex;
+        align-items: center;
+    }
+    .vitviz-info-icon {
+        display: inline-flex;
+        align-items: center;
+        justify-content: center;
+        width: 16px;
+        height: 16px;
+        border-radius: 999px;
+        border: 1px solid rgba(255, 255, 255, 0.40);
+        color: rgba(255, 255, 255, 0.82);
+        font-size: 11px;
+        font-weight: 700;
+        line-height: 1;
+        cursor: help;
+        user-select: none;
+    }
+    .vitviz-tooltip {
+        position: absolute;
+        left: calc(100% + 8px);
+        top: 50%;
+        transform: translateY(-50%);
+        background: #2a2a2a;
+        color: #ffffff;
+        border: 1px solid rgba(255, 255, 255, 0.14);
+        border-radius: 8px;
+        box-shadow: 0 8px 20px rgba(0, 0, 0, 0.35);
+        font-size: 12px;
+        line-height: 1.35;
+        font-weight: 450;
+        padding: 8px 10px;
+        width: max-content;
+        max-width: min(360px, 60vw);
+        white-space: normal;
+        opacity: 0;
+        visibility: hidden;
+        pointer-events: none;
+        z-index: 50;
+        transition: none;
+    }
+    .vitviz-tooltip::before {
+        content: "";
+        position: absolute;
+        left: -6px;
+        top: 50%;
+        transform: translateY(-50%);
+        width: 0;
+        height: 0;
+        border-top: 6px solid transparent;
+        border-bottom: 6px solid transparent;
+        border-right: 6px solid #2a2a2a;
+    }
+    .vitviz-tooltip-wrap:hover .vitviz-tooltip,
+    .vitviz-tooltip-wrap:focus-within .vitviz-tooltip {
+        opacity: 1;
+        visibility: visible;
+    }
+    .vitviz-info-icon:hover,
+    .vitviz-info-icon:focus-visible {
+        border-color: #84cbff;
+        color: #84cbff;
+        outline: none;
+    }
+    @media (max-width: 900px) {
+        .vitviz-tooltip {
+            left: 50%;
+            top: calc(100% + 8px);
+            transform: translateX(-50%);
+            max-width: min(320px, 82vw);
+        }
+        .vitviz-tooltip::before {
+            left: 50%;
+            top: -6px;
+            transform: translateX(-50%);
+            border-left: 6px solid transparent;
+            border-right: 6px solid transparent;
+            border-bottom: 6px solid #2a2a2a;
+            border-top: 0;
+        }
+    }
     .vitviz-details {
         width: 100%;
     }
@@ -864,6 +1016,27 @@ def create_app():
                         inputs=[attack_type],
                         outputs=[alpha_group, steps_group, decay_group, vit_weight_slider]
                     )
+
+                    metrics_selector = gr.Dropdown(
+                        choices=METRIC_DROPDOWN_OPTIONS,
+                        value=METRIC_OPTIONS,
+                        multiselect=True,
+                        label="Metrics in Report",
+                        info="Choose which perturbation metrics should be displayed. Select All enables all metrics."
+                    )
+
+                    def update_metric_selection(selected_values):
+                        selected_values = selected_values or []
+                        if "Select All" in selected_values:
+                            return gr.update(value=METRIC_OPTIONS)
+                        filtered = [m for m in METRIC_OPTIONS if m in selected_values]
+                        return gr.update(value=filtered)
+
+                    metrics_selector.change(
+                        fn=update_metric_selection,
+                        inputs=[metrics_selector],
+                        outputs=[metrics_selector]
+                    )
                     
                     attack_btn = gr.Button("Execute Full Analysis", variant="primary", size="lg")
                     
@@ -1039,7 +1212,8 @@ def create_app():
                     fn=run_attack,
                     inputs=[
                         model_upload_attack, model_select_attack, image_upload_attack,
-                        attack_type, eps_input, alpha_input, steps_input, decay_input, vit_weight_slider
+                        attack_type, eps_input, alpha_input, steps_input, decay_input, vit_weight_slider,
+                        metrics_selector
                     ],
                     outputs=[iteration_images_state, output_text_attack, cached_attentions_state]
                 ).then(

configs/default.yaml

@@ -0,0 +1,101 @@
+# ViTViz Default Configuration
+# =============================
+# Base config for all experiments. Override in configs/experiments/*.yaml.
+
+# Available models (same as app.py)
+models:
+  - name: "ViT-B/16 · Stanford40"
+    path: "hf-model://lucasddmc/vit-b16-stanford40-actions"
+    type: "hf-vit"
+    dataset: "Stanford40 Actions"
+    img_size: 224
+    num_classes: 40
+
+  - name: "ViT-B/32 · ImageNet-1k"
+    path: "hf-model://google/vit-base-patch32-384"
+    type: "hf-vit"
+    dataset: "ImageNet-1k"
+    img_size: 384
+    num_classes: 1000
+
+  - name: "ViT-L/16 · ImageNet-1k"
+    path: "hf-model://google/vit-large-patch16-224"
+    type: "hf-vit"
+    dataset: "ImageNet-1k"
+    img_size: 224
+    num_classes: 1000
+
+  - name: "DeiT-S/16 · ImageNet-1k"
+    path: "hf-model://facebook/deit-small-patch16-224"
+    type: "hf-vit"
+    dataset: "ImageNet-1k"
+    img_size: 224
+    num_classes: 1000
+
+# Attack methods with default hyperparameters
+attacks:
+  - name: "FGSM"
+    params:
+      eps: null  # set per evaluation.epsilons
+
+  - name: "PGD"
+    params:
+      eps: null
+      alpha_ratio: 0.25  # alpha = eps * alpha_ratio
+      steps: 10
+
+  - name: "MIM"
+    params:
+      eps: null
+      alpha_ratio: 0.25
+      steps: 10
+      decay: 1.0
+
+  - name: "TGR"
+    params:
+      eps: null
+      alpha_ratio: 0.25
+      steps: 10
+      gamma_attn: 0.25
+      gamma_qkv: 0.75
+      gamma_mlp: 0.5
+
+  - name: "SAGA"
+    params:
+      eps: null
+      alpha_ratio: 0.25
+      steps: 10
+      cnn_backbone: null  # ViT-only SAGA (no blending)
+
+# Evaluation setup
+evaluation:
+  # Epsilon values in [0,1] space (will also compute eps/255 for convenience)
+  epsilons:
+    - 0.00784  # ~2/255
+
+  # Random seeds for reproducibility
+  seeds: [42, 123, 456, 789, 2026]
+
+  # Top-k for accuracy drop metric
+  topk: 5
+
+  # Whether to compute LPIPS (slower)
+  compute_lpips: true
+
+# Attention analysis
+attention:
+  discard_ratio: 0.9
+  head_fusion: "max"
+
+# Output paths
+output:
+  results_dir: "results/raw"
+  figures_dir: "results/figures"
+  tables_dir: "results/tables"
+
+# Input data
+data:
+  images_dir: "data/sample_images"
+
+# Device
+device: "auto"  # "auto", "cuda", "cpu"

configs/experiments/exp_all_attacks.yaml

@@ -0,0 +1,25 @@
+# Experiment: All Attacks × All Models
+# ============================================================================
+# Full sweep across all models, all attacks, all epsilons, 5 seeds.
+# Estimated time: ~4-8h on single GPU (depends on model size).
+#
+# Usage:
+#   python experiments/run_attack_sweep.py --config configs/experiments/exp_all_attacks.yaml
+
+# Inherit defaults from ../default.yaml (loaded programmatically)
+# Only override what's different.
+
+# Use all models from default.yaml
+# models: (inherited)
+
+# Use all attacks from default.yaml
+# attacks: (inherited)
+
+# Use all epsilons and seeds from default.yaml
+# evaluation: (inherited)
+
+# Output gets its own subdirectory
+output:
+  results_dir: "results/raw/exp_all_attacks"
+  figures_dir: "results/figures/exp_all_attacks"
+  tables_dir: "results/tables/exp_all_attacks"

configs/experiments/exp_quick_test.yaml

@@ -0,0 +1,32 @@
+# Experiment: Quick test (sanity check)
+# ============================================================================
+# Single model, single attack, single epsilon, single seed.
+# Use to verify the pipeline works before running the full sweep.
+#
+# Usage:
+#   python experiments/run_attack_sweep.py --config configs/experiments/exp_quick_test.yaml
+
+models:
+  - name: "DeiT-S/16 · ImageNet-1k"
+    path: "hf-model://facebook/deit-small-patch16-224"
+    type: "hf-vit"
+    dataset: "ImageNet-1k"
+    img_size: 224
+    num_classes: 1000
+
+attacks:
+  - name: "FGSM"
+    params:
+      eps: null
+
+evaluation:
+  epsilons:
+    - 0.03137  # 8/255
+  seeds: [42]
+  topk: 5
+  compute_lpips: false  # faster
+
+output:
+  results_dir: "results/raw/exp_quick_test"
+  figures_dir: "results/figures/exp_quick_test"
+  tables_dir: "results/tables/exp_quick_test"

data/download_samples.py

@@ -0,0 +1,107 @@
+#!/usr/bin/env python3
+"""Download sample ImageNet-1k images via HuggingFace Datasets (streaming).
+
+Requirements:
+  1. Accept the dataset agreement at: https://huggingface.co/datasets/imagenet-1k
+  2. Login: huggingface-cli login   (or set HF_TOKEN env var)
+  3. pip install datasets
+
+Usage:
+    python data/download_samples.py
+    python data/download_samples.py --n-per-class 2 --output data/sample_images
+"""
+
+import argparse
+import json
+from pathlib import Path
+
+# Classes desejadas: {class_id: filename_prefix}
+TARGET_CLASSES = {
+    281: "tabby_cat",
+    207: "golden_retriever",
+    985: "daisy",
+    530: "digital_clock",
+    817: "sports_car",
+    291: "lion",
+    949: "strawberry",
+    388: "giant_panda",
+    562: "fountain",
+    717: "pickup_truck",
+}
+
+
+def download_samples(output_dir: Path, n_per_class: int = 1):
+    try:
+        from datasets import load_dataset
+    except ImportError:
+        print("ERROR: instale o pacote com: pip install datasets")
+        raise
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    print("Carregando ImageNet-1k via streaming (sem baixar o dataset completo)...")
+    print("Isso pode levar alguns minutos na primeira execução.")
+    print()
+
+    ds = load_dataset(
+        "imagenet-1k",
+        split="validation",
+        streaming=True,
+    )
+
+    # Rastrear quantas imagens já temos por classe
+    collected = {cls_id: 0 for cls_id in TARGET_CLASSES}
+    total_needed = len(TARGET_CLASSES) * n_per_class
+    total_saved = 0
+
+    for sample in ds:
+        cls_id = sample["label"]
+        if cls_id not in collected:
+            continue
+        if collected[cls_id] >= n_per_class:
+            continue
+
+        name = TARGET_CLASSES[cls_id]
+        idx = collected[cls_id]
+        suffix = f"_{idx+1}" if n_per_class > 1 else ""
+        filename = output_dir / f"{name}{suffix}.JPEG"
+
+        sample["image"].save(filename)
+        collected[cls_id] += 1
+        total_saved += 1
+        print(f"  [{total_saved}/{total_needed}] {filename.name} (classe {cls_id})")
+
+        if total_saved >= total_needed:
+            break
+
+    # Verificar quais classes ficaram sem imagens
+    missing = [TARGET_CLASSES[k] for k, v in collected.items() if v < n_per_class]
+    if missing:
+        print(f"\nAVISO: não encontradas: {missing}")
+    else:
+        print(f"\nConcluído! {total_saved} imagens salvas em {output_dir}")
+
+    # Atualizar metadata.json com os arquivos baixados
+    meta_path = output_dir / "metadata.json"
+    if meta_path.exists():
+        with open(meta_path) as f:
+            meta = json.load(f)
+        meta["downloaded_files"] = [
+            f"{TARGET_CLASSES[k]}{'_' + str(i+1) if n_per_class > 1 else ''}.JPEG"
+            for k in TARGET_CLASSES
+            for i in range(n_per_class)
+            if (output_dir / f"{TARGET_CLASSES[k]}{'_' + str(i+1) if n_per_class > 1 else ''}.JPEG").exists()
+        ]
+        with open(meta_path, "w") as f:
+            json.dump(meta, f, indent=2)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Download ImageNet sample images")
+    parser.add_argument("--n-per-class", type=int, default=1,
+                        help="Imagens por classe (default: 1)")
+    parser.add_argument("--output", type=str, default="data/sample_images",
+                        help="Diretório de saída")
+    args = parser.parse_args()
+
+    download_samples(Path(args.output), args.n_per_class)

data/sample_images/.gitkeep

@@ -0,0 +1,3 @@
+# This file ensures the directory is tracked by git.
+# Add sample images (.jpg, .png) here for batch experiments.
+# These images will be excluded from git by .gitignore.

data/sample_images/metadata.json

@@ -0,0 +1,59 @@
+{
+  "description": "Sample images for ViTViz experiments",
+  "instructions": "Add ImageNet validation images here. Recommended: 10-20 diverse images.",
+  "naming_convention": "ILSVRC2012_val_NNNNN.JPEG or descriptive names (e.g., cat.jpg, car.jpg)",
+  "suggested_classes": [
+    {
+      "imagenet_id": 281,
+      "name": "tabby cat"
+    },
+    {
+      "imagenet_id": 207,
+      "name": "golden retriever"
+    },
+    {
+      "imagenet_id": 985,
+      "name": "daisy"
+    },
+    {
+      "imagenet_id": 530,
+      "name": "digital clock"
+    },
+    {
+      "imagenet_id": 817,
+      "name": "sports car"
+    },
+    {
+      "imagenet_id": 291,
+      "name": "lion"
+    },
+    {
+      "imagenet_id": 949,
+      "name": "strawberry"
+    },
+    {
+      "imagenet_id": 388,
+      "name": "giant panda"
+    },
+    {
+      "imagenet_id": 562,
+      "name": "fountain"
+    },
+    {
+      "imagenet_id": 717,
+      "name": "pickup truck"
+    }
+  ],
+  "downloaded_files": [
+    "tabby_cat.JPEG",
+    "golden_retriever.JPEG",
+    "daisy.JPEG",
+    "digital_clock.JPEG",
+    "sports_car.JPEG",
+    "lion.JPEG",
+    "strawberry.JPEG",
+    "giant_panda.JPEG",
+    "fountain.JPEG",
+    "pickup_truck.JPEG"
+  ]
+}

experiments/run_attack_sweep.py

@@ -0,0 +1,398 @@
+#!/usr/bin/env python3
+"""Run adversarial attack sweep across models × attacks × epsilons × seeds.
+
+Produces a CSV with all metrics for each combination and saves adversarial
+images. Designed to run headless (no Gradio) on any machine.
+
+Usage:
+    # Full sweep with default config
+    python experiments/run_attack_sweep.py
+
+    # Custom experiment config
+    python experiments/run_attack_sweep.py --config configs/experiments/exp_quick_test.yaml
+
+    # Dry run (list combinations without executing)
+    python experiments/run_attack_sweep.py --dry-run
+
+    # Resume interrupted run
+    python experiments/run_attack_sweep.py --resume
+"""
+
+import argparse
+import csv
+import os
+import sys
+import time
+from pathlib import Path
+
+# Add project root to path
+def _find_project_root() -> Path:
+    """Find project root by walking up the directory tree until requirements.txt is found."""
+    current = Path(__file__).resolve().parent
+    for parent in [current, *current.parents]:
+        if (parent / "requirements.txt").exists():
+            return parent
+    raise RuntimeError(f"Project root not found starting from {__file__}")
+
+PROJECT_ROOT = _find_project_root()
+sys.path.insert(0, str(PROJECT_ROOT))
+
+import numpy as np
+import torch
+import yaml
+from PIL import Image
+from tqdm import tqdm
+
+from utils.attacks import (
+    FGSM,
+    MIFGSM,
+    PGDIterations,
+    SAGA,
+    TGR,
+)
+from utils.inference import predict_topk
+from utils.metrics import (
+    compute_all_attack_metrics,
+    compute_all_image_metrics,
+)
+from utils.model_loader import load_model_and_labels
+from utils.preprocessing import get_default_transform, preprocess_image
+from utils.seed import set_seed
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# Config loading
+# ═══════════════════════════════════════════════════════════════════════════
+
+def load_config(config_path: str) -> dict:
+    """Load experiment config with inheritance from default.yaml."""
+    default_path = PROJECT_ROOT / "configs" / "default.yaml"
+
+    with open(default_path) as f:
+        config = yaml.safe_load(f)
+
+    if config_path and Path(config_path).exists():
+        with open(config_path) as f:
+            overrides = yaml.safe_load(f) or {}
+        # Deep merge: override top-level keys
+        for key, value in overrides.items():
+            if isinstance(value, dict) and key in config and isinstance(config[key], dict):
+                config[key].update(value)
+            else:
+                config[key] = value
+
+    return config
+
+
+def get_device(config: dict) -> torch.device:
+    """Resolve device from config."""
+    dev = config.get("device", "auto")
+    if dev == "auto":
+        return torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    return torch.device(dev)
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# Attack factory
+# ═══════════════════════════════════════════════════════════════════════════
+
+def create_attack(model, attack_cfg: dict, eps: float):
+    """Instantiate an attack from config dict."""
+    name = attack_cfg["name"]
+    params = attack_cfg.get("params", {})
+
+    if name == "FGSM":
+        return FGSM(model, eps=eps, collect_images=False)
+
+    elif name == "PGD":
+        alpha = eps * params.get("alpha_ratio", 0.25)
+        steps = params.get("steps", 10)
+        return PGDIterations(model, eps=eps, alpha=alpha, steps=steps, random_start=False, collect_images=False)
+
+    elif name == "MIM":
+        alpha = eps * params.get("alpha_ratio", 0.25)
+        steps = params.get("steps", 10)
+        decay = params.get("decay", 1.0)
+        return MIFGSM(model, eps=eps, alpha=alpha, steps=steps, decay=decay, collect_images=False)
+
+    elif name == "TGR":
+        steps = params.get("steps", 10)
+        decay = params.get("decay", 1.0)
+        return TGR(model, eps=eps, steps=steps, decay=decay, collect_images=False)
+
+    elif name == "SAGA":
+        steps = params.get("steps", 10)
+        cnn = params.get("cnn_backbone")
+        return SAGA(model, eps=eps, steps=steps, use_resnet=bool(cnn), cnn_checkpoint_path=cnn, collect_images=False)
+
+    else:
+        raise ValueError(f"Unknown attack: {name}")
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# CSV columns
+# ═══════════════════════════════════════════════════════════════════════════
+
+CSV_COLUMNS = [
+    "model", "attack", "epsilon", "seed", "image",
+    "orig_pred", "orig_conf", "adv_pred", "adv_conf",
+    # Attack success
+    "asr", "confidence_drop", "topk_drop",
+    # Image quality
+    "linf", "l2", "psnr", "ssim", "lpips", "modified_pixels",
+    # Timing
+    "time_seconds",
+]
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# Main sweep
+# ═══════════════════════════════════════════════════════════════════════════
+
+def build_combinations(config: dict, image_dir: Path, allow_empty: bool = False) -> list:
+    """Generate all (model, attack, epsilon, seed, image) combinations."""
+    models = config["models"]
+    attacks = config["attacks"]
+    epsilons = config["evaluation"]["epsilons"]
+    seeds = config["evaluation"]["seeds"]
+
+    images = sorted(
+        p for p in image_dir.iterdir()
+        if p.suffix.lower() in {".jpg", ".jpeg", ".png", ".bmp", ".webp"}
+    ) if image_dir.exists() else []
+
+    if not images and not allow_empty:
+        print(f"ERROR: No images found in {image_dir}")
+        sys.exit(1)
+
+    if not images:
+        # Dry-run mode: show config summary without images
+        return [(m, a, e, s, Path("(no images)")) for m in models for a in attacks for e in epsilons for s in seeds]
+
+    combos = []
+    for model_cfg in models:
+        for attack_cfg in attacks:
+            for eps in epsilons:
+                for seed in seeds:
+                    for img_path in images:
+                        combos.append((model_cfg, attack_cfg, eps, seed, img_path))
+
+    return combos
+
+
+def get_completed_keys(csv_path: Path) -> set:
+    """Read existing CSV to find completed runs (for --resume)."""
+    if not csv_path.exists():
+        return set()
+    keys = set()
+    with open(csv_path) as f:
+        reader = csv.DictReader(f)
+        for row in reader:
+            key = (row["model"], row["attack"], row["epsilon"], row["seed"], row["image"])
+            keys.add(key)
+    return keys
+
+
+def run_single(
+    model, vit_config, class_names,
+    attack_cfg: dict, eps: float, seed: int,
+    img_path: Path, device: torch.device,
+    eval_cfg: dict, attn_cfg: dict,
+) -> dict:
+    """Run a single attack and compute all metrics. Returns a dict row."""
+    set_seed(seed)
+
+    # Preprocess
+    transform = get_default_transform(img_size=vit_config.img_size)
+    img_tensor = preprocess_image(str(img_path), transform=transform).to(device)
+
+    # Original prediction
+    model.eval()
+    with torch.no_grad():
+        orig_out = model(img_tensor)
+        if isinstance(orig_out, tuple):
+            orig_out = orig_out[0]
+        orig_logits = orig_out[0]  # shape [num_classes]
+        orig_probs = torch.nn.functional.softmax(orig_logits, dim=0)
+        orig_pred = orig_probs.argmax().item()
+        orig_conf = orig_probs[orig_pred].item()
+
+    # Create and run attack
+    attack = create_attack(model, attack_cfg, eps)
+    original_label = torch.tensor([orig_pred], device=device)
+
+    t0 = time.time()
+    adv_tensor, _ = attack(img_tensor, original_label)
+    elapsed = time.time() - t0
+
+    # Adversarial prediction
+    with torch.no_grad():
+        adv_out = model(adv_tensor)
+        if isinstance(adv_out, tuple):
+            adv_out = adv_out[0]
+        adv_logits = adv_out[0]
+        adv_probs = torch.nn.functional.softmax(adv_logits, dim=0)
+        adv_pred = adv_probs.argmax().item()
+        adv_conf = adv_probs[adv_pred].item()
+
+    # Image quality metrics
+    use_lpips = eval_cfg.get("compute_lpips", True)
+    img_metrics = compute_all_image_metrics(img_tensor, adv_tensor, use_lpips=use_lpips)
+
+    # Attack success metrics
+    atk_metrics = compute_all_attack_metrics(
+        orig_probs, adv_probs, orig_pred, adv_pred,
+        k=eval_cfg.get("topk", 5),
+        orig_logits=orig_logits, adv_logits=adv_logits,
+    )
+
+    # Build row
+    row = {
+        "model": attack_cfg.get("_model_name", "unknown"),
+        "attack": attack_cfg["name"],
+        "epsilon": f"{eps:.5f}",
+        "seed": str(seed),
+        "image": img_path.name,
+        "orig_pred": str(orig_pred),
+        "orig_conf": f"{orig_conf:.6f}",
+        "adv_pred": str(adv_pred),
+        "adv_conf": f"{adv_conf:.6f}",
+        **{k: f"{v:.6f}" for k, v in atk_metrics.items()},
+        **{k: f"{v:.6f}" for k, v in img_metrics.items()},
+        "time_seconds": f"{elapsed:.2f}",
+    }
+
+    return row
+
+
+def main():
+    parser = argparse.ArgumentParser(description="ViTViz Attack Sweep Experiment")
+    parser.add_argument(
+        "--config", type=str, default=None,
+        help="Experiment config YAML (inherits from configs/default.yaml)",
+    )
+    parser.add_argument("--dry-run", action="store_true", help="List combinations without executing")
+    parser.add_argument("--resume", action="store_true", help="Skip already-completed runs in CSV")
+    parser.add_argument("--device", type=str, default=None, help="Override device (cuda/cpu)")
+    parser.add_argument("--output", type=str, default=None, help="Override output CSV path")
+    args = parser.parse_args()
+
+    # Load config
+    config = load_config(args.config)
+    device = torch.device(args.device) if args.device else get_device(config)
+
+    print(f"Device: {device}")
+    print(f"Config: {args.config or 'default'}")
+
+    # Resolve paths
+    results_dir = Path(config["output"]["results_dir"])
+    results_dir.mkdir(parents=True, exist_ok=True)
+    images_dir = Path(config["data"]["images_dir"])
+
+    if not images_dir.exists():
+        images_dir.mkdir(parents=True, exist_ok=True)
+        if not args.dry_run:
+            print(f"ERROR: Images directory is empty: {images_dir}")
+            print("  → Add sample images to data/sample_images/")
+            sys.exit(1)
+
+    # Build combinations
+    combos = build_combinations(config, images_dir, allow_empty=args.dry_run)
+    print(f"Total combinations: {len(combos)}")
+    print(f"  Models: {len(config['models'])}")
+    print(f"  Attacks: {len(config['attacks'])}")
+    print(f"  Epsilons: {len(config['evaluation']['epsilons'])}")
+    print(f"  Seeds: {len(config['evaluation']['seeds'])}")
+    image_exts = {".jpg", ".jpeg", ".png", ".bmp", ".webp", ".JPEG"}
+    print(f"  Images: {len([p for p in images_dir.iterdir() if p.suffix.lower() in image_exts])}")
+
+    if args.dry_run:
+        print("\n--- Dry Run: combinations ---")
+        for i, (m, a, e, s, img) in enumerate(combos[:20]):
+            print(f"  [{i+1}] {m['name']} × {a['name']} × ε={e:.5f} × seed={s} × {img.name}")
+        if len(combos) > 20:
+            print(f"  ... and {len(combos) - 20} more")
+        return
+
+    # Output CSV
+    csv_path = Path(args.output) if args.output else results_dir / "results.csv"
+    csv_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Resume support
+    completed = get_completed_keys(csv_path) if args.resume else set()
+    if completed: # if not an empty set
+        print(f"Resuming: {len(completed)} runs already completed")
+
+    # Write header if new file
+    write_header = not csv_path.exists() or not args.resume
+    if write_header:
+        with open(csv_path, "w", newline="") as f:
+            writer = csv.DictWriter(f, fieldnames=CSV_COLUMNS)
+            writer.writeheader()
+
+    # Cache loaded models to avoid reloading
+    model_cache = {}  # TODO: add LRU eviction if too many models
+
+    # Run sweep
+    pbar = tqdm(combos, desc="Attack sweep", unit="run")
+    success_count = 0
+    error_count = 0
+
+    for model_cfg, attack_cfg, eps, seed, img_path in pbar:
+        model_name = model_cfg["name"]
+        attack_name = attack_cfg["name"]
+
+        # Check resume
+        key = (model_name, attack_name, f"{eps:.5f}", str(seed), img_path.name)
+        if key in completed:
+            continue
+
+        pbar.set_postfix_str(f"{model_name[:15]}|{attack_name}|ε={eps:.4f}|s={seed}")
+
+        # Load model (cached)
+        if model_name not in model_cache:
+            try:
+                print(f"\n  Loading model: {model_name}...")
+                model, class_names, _, vit_config = load_model_and_labels(
+                    model_cfg["path"], None, device=device
+                )
+                model_cache[model_name] = (model, class_names, vit_config)
+            except Exception as e:
+                print(f"\n  ERROR loading model {model_name}: {e}")
+                error_count += 1
+                continue
+
+        model, class_names, vit_config = model_cache[model_name]
+
+        # Inject model name into attack config for CSV
+        attack_cfg_copy = dict(attack_cfg)
+        attack_cfg_copy["_model_name"] = model_name
+
+        try:
+            row = run_single(
+                model, vit_config, class_names,
+                attack_cfg_copy, eps, seed, img_path, device,
+                config["evaluation"], config.get("attention", {}),
+            )
+
+            # Append to CSV
+            with open(csv_path, "a", newline="") as f:
+                writer = csv.DictWriter(f, fieldnames=CSV_COLUMNS)
+                writer.writerow(row)
+
+            success_count += 1
+
+        except Exception as e:
+            print(f"\n  ERROR: {model_name} × {attack_name} × ε={eps} × seed={seed} × {img_path.name}: {e}")
+            error_count += 1
+
+    print(f"\n{'='*60}")
+    print(f"Sweep complete!")
+    print(f"  Successful: {success_count}")
+    print(f"  Errors:     {error_count}")
+    print(f"  Results:    {csv_path}")
+    print(f"{'='*60}")
+
+
+if __name__ == "__main__":
+    main()

experiments/run_attention_analysis.py

@@ -0,0 +1,268 @@
+#!/usr/bin/env python3
+"""Capture detailed attention maps for visualization in the paper.
+
+For a given model + image + attack, saves:
+- Attention rollout maps (original and adversarial) as .npy and .png
+- Per-layer attention heatmaps
+- Overlay images
+Usage:
+    python experiments/run_attention_analysis.py \
+        --model "hf-model://facebook/deit-small-patch16-224" \
+        --image data/sample_images/cat.jpg \
+        --attack FGSM --eps 0.03137
+
+    # Or with config (analyzes all combinations)
+    python experiments/run_attention_analysis.py --config configs/default.yaml --all
+"""
+
+import argparse
+import json
+import os
+import sys
+from pathlib import Path
+
+PROJECT_ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(PROJECT_ROOT))
+
+import numpy as np
+import torch
+import yaml
+from PIL import Image
+
+from utils.attacks import FGSM, MIFGSM, PGDIterations, SAGA, TGR, capture_outputs_and_attentions
+from utils.inference import predict_topk
+from utils.model_loader import load_model_and_labels
+from utils.preprocessing import get_default_transform, preprocess_image
+from utils.seed import set_seed
+from utils.visualization import attention_rollout, create_attention_overlay
+
+
+def save_rollout_artifacts(
+    output_dir: Path,
+    prefix: str,
+    rollout_map: np.ndarray,
+    original_image: Image.Image,
+    alpha: float = 0.5,
+):
+    """Save rollout map as .npy and overlay .png."""
+    np.save(output_dir / f"{prefix}_rollout.npy", rollout_map)
+
+    overlay = create_attention_overlay(original_image, rollout_map, alpha=alpha)
+    overlay.save(output_dir / f"{prefix}_overlay.png")
+
+    # Save raw heatmap
+    import matplotlib.pyplot as plt
+    import matplotlib.cm as cm
+
+    fig, ax = plt.subplots(1, 1, figsize=(4, 4))
+    ax.imshow(rollout_map, cmap="jet", interpolation="nearest")
+    ax.set_title(prefix)
+    ax.axis("off")
+    fig.tight_layout()
+    fig.savefig(output_dir / f"{prefix}_heatmap.png", dpi=150, bbox_inches="tight")
+    plt.close(fig)
+
+
+def analyze_single(
+    model_path: str,
+    img_path: str,
+    attack_name: str,
+    eps: float,
+    seed: int,
+    output_base: str,
+    device: torch.device,
+    discard_ratio: float = 0.9,
+    head_fusion: str = "max",
+    attack_params: dict = None,
+):
+    """Full attention analysis for one model × image × attack combination."""
+    set_seed(seed)
+
+    # Load model
+    model, class_names, _, vit_config = load_model_and_labels(model_path, None, device=device)
+    transform = get_default_transform(img_size=vit_config.img_size)
+
+    # Load image
+    pil_img = Image.open(img_path).convert("RGB")
+    img_tensor = preprocess_image(pil_img, transform=transform).to(device)
+
+    # Output directory
+    img_name = Path(img_path).stem
+    safe_model = model_path.split("/")[-1] if "/" in model_path else "custom"
+    dir_name = f"{safe_model}_{attack_name}_eps{eps:.4f}_{img_name}_seed{seed}"
+    output_dir = Path(output_base) / dir_name
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    print(f"  Output: {output_dir}")
+
+    # Original prediction & attention
+    _, attns_orig = capture_outputs_and_attentions(model, img_tensor)
+    top_prob, top_idx, _, orig_probs = predict_topk(model, img_tensor, top_k=5, device=device)
+    orig_pred = top_idx[0].item()
+
+    rollout_orig = attention_rollout(attns_orig, discard_ratio=discard_ratio, head_fusion=head_fusion)
+
+    # Resize original image to match model input
+    resized = pil_img.resize(
+        (vit_config.img_size, vit_config.img_size), Image.LANCZOS
+    )
+    resized.save(output_dir / "original.png")
+    save_rollout_artifacts(output_dir, "original", rollout_orig, resized)
+
+    # Run attack
+    params = attack_params or {}
+    if attack_name == "FGSM":
+        attack = FGSM(model, eps=eps, collect_images=False)
+    elif attack_name == "PGD":
+        alpha = eps * params.get("alpha_ratio", 0.25)
+        attack = PGDIterations(model, eps=eps, alpha=alpha, steps=params.get("steps", 10), collect_images=False)
+    elif attack_name == "MIM":
+        alpha = eps * params.get("alpha_ratio", 0.25)
+        attack = MIFGSM(model, eps=eps, alpha=alpha, steps=params.get("steps", 10), collect_images=False)
+    elif attack_name == "TGR":
+        attack = TGR(model, eps=eps, steps=params.get("steps", 10), collect_images=False)
+    elif attack_name == "SAGA":
+        attack = SAGA(model, eps=eps, steps=params.get("steps", 10), collect_images=False)
+    else:
+        raise ValueError(f"Unknown attack: {attack_name}")
+
+    label_tensor = torch.tensor([orig_pred], device=device)
+    adv_tensor, _ = attack(img_tensor, label_tensor)
+
+    # Adversarial prediction & attention (reuse attentions captured during attack)
+    attns_adv = attack.attentions_per_iter[-1] if attack.attentions_per_iter else None
+    _, top_idx_adv, _, adv_probs = predict_topk(model, adv_tensor, top_k=5, device=device)
+    adv_pred = top_idx_adv[0].item()
+
+    if attns_adv is None:
+        _, attns_adv = capture_outputs_and_attentions(model, adv_tensor)
+
+    rollout_adv = attention_rollout(attns_adv, discard_ratio=discard_ratio, head_fusion=head_fusion)
+
+    # Save adversarial image
+    from utils.attacks import denormalize_imagenet, tensor_to_pil
+    adv_pil = tensor_to_pil(adv_tensor[0])
+    adv_pil.save(output_dir / "adversarial.png")
+    save_rollout_artifacts(output_dir, "adversarial", rollout_adv, adv_pil)
+
+    # Side-by-side comparison figure
+    import matplotlib.pyplot as plt
+
+    fig, axes = plt.subplots(1, 4, figsize=(16, 4))
+
+    axes[0].imshow(resized)
+    axes[0].set_title("Original")
+    axes[0].axis("off")
+
+    axes[1].imshow(rollout_orig, cmap="jet")
+    orig_label = class_names.get(orig_pred, f"Class {orig_pred}") if class_names else f"Class {orig_pred}"
+    axes[1].set_title(f"Attn: {orig_label}")
+    axes[1].axis("off")
+
+    axes[2].imshow(adv_pil)
+    axes[2].set_title("Adversarial")
+    axes[2].axis("off")
+
+    axes[3].imshow(rollout_adv, cmap="jet")
+    adv_label = class_names.get(adv_pred, f"Class {adv_pred}") if class_names else f"Class {adv_pred}"
+    axes[3].set_title(f"Attn: {adv_label}")
+    axes[3].axis("off")
+
+    fig.suptitle(f"{attack_name} (ε={eps:.4f})", fontsize=14)
+    fig.tight_layout()
+    fig.savefig(output_dir / "comparison.png", dpi=200)
+    plt.close(fig)
+
+    # Save summary JSON
+    summary = {
+        "model": model_path,
+        "image": str(img_path),
+        "attack": attack_name,
+        "epsilon": eps,
+        "seed": seed,
+        "orig_pred": orig_pred,
+        "orig_label": orig_label,
+        "adv_pred": adv_pred,
+        "adv_label": adv_label,
+    }
+    with open(output_dir / "summary.json", "w") as f:
+        json.dump(summary, f, indent=2)
+
+    print(f"  Pred: {orig_label} → {adv_label}")
+
+    return summary
+
+
+def main():
+    parser = argparse.ArgumentParser(description="ViTViz Attention Analysis")
+    parser.add_argument("--model", type=str, help="Model path or hf-model:// URI")
+    parser.add_argument("--image", type=str, help="Path to input image")
+    parser.add_argument("--attack", type=str, default="FGSM", help="Attack name")
+    parser.add_argument("--eps", type=float, default=0.03137, help="Epsilon (default: ~8/255)")
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--output", type=str, default="results/raw/attention")
+    parser.add_argument("--device", type=str, default=None)
+    parser.add_argument("--discard-ratio", type=float, default=0.9)
+    parser.add_argument("--head-fusion", type=str, default="max")
+
+    # Batch mode
+    parser.add_argument("--config", type=str, help="Config YAML for batch mode")
+    parser.add_argument("--all", action="store_true", help="Analyze all combos from config")
+
+    args = parser.parse_args()
+
+    device = torch.device(args.device) if args.device else torch.device(
+        "cuda" if torch.cuda.is_available() else "cpu"
+    )
+    print(f"Device: {device}")
+
+    if args.all and args.config:
+        # Batch mode: iterate over config
+        default_path = PROJECT_ROOT / "configs" / "default.yaml"
+        with open(default_path) as f:
+            config = yaml.safe_load(f)
+        if args.config:
+            with open(args.config) as f:
+                overrides = yaml.safe_load(f) or {}
+            for k, v in overrides.items():
+                if isinstance(v, dict) and k in config:
+                    config[k].update(v)
+                else:
+                    config[k] = v
+
+        images_dir = Path(config["data"]["images_dir"])
+        images = sorted(
+            p for p in images_dir.iterdir()
+            if p.suffix.lower() in {".jpg", ".jpeg", ".png", ".JPEG"}
+        )
+
+        for model_cfg in config["models"]:
+            for attack_cfg in config["attacks"]:
+                for eps in config["evaluation"]["epsilons"]:
+                    for img_path in images:
+                        print(f"\n--- {model_cfg['name']} × {attack_cfg['name']} × ε={eps} × {img_path.name} ---")
+                        try:
+                            analyze_single(
+                                model_cfg["path"], str(img_path),
+                                attack_cfg["name"], eps,
+                                seed=config["evaluation"]["seeds"][0],
+                                output_base=args.output, device=device,
+                                discard_ratio=args.discard_ratio,
+                                head_fusion=args.head_fusion,
+                                attack_params=attack_cfg.get("params", {}),
+                            )
+                        except Exception as e:
+                            print(f"  ERROR: {e}")
+    else:
+        # Single mode
+        if not args.model or not args.image:
+            parser.error("--model and --image are required in single mode (or use --config + --all)")
+        analyze_single(
+            args.model, args.image, args.attack, args.eps,
+            args.seed, args.output, device,
+            args.discard_ratio, args.head_fusion,
+        )
+
+
+if __name__ == "__main__":
+    main()

notebooks/01-metrics-analysis.ipynb

@@ -0,0 +1,177 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "82a50f9e",
+   "metadata": {},
+   "source": [
+    "# ViTViz - Metrics Analysis\n",
+    "\n",
+    "Load experiment results from `results/raw/results.csv` and generate tables/figures for the paper."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6781cd0c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import matplotlib\n",
+    "matplotlib.rcParams.update({'font.size': 11, 'font.family': 'serif'})\n",
+    "\n",
+    "from pathlib import Path\n",
+    "\n",
+    "RESULTS_CSV = Path('../results/raw/results.csv')\n",
+    "FIGURES_DIR = Path('../results/figures')\n",
+    "TABLES_DIR = Path('../results/tables')\n",
+    "FIGURES_DIR.mkdir(parents=True, exist_ok=True)\n",
+    "TABLES_DIR.mkdir(parents=True, exist_ok=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "03122534",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df = pd.read_csv(RESULTS_CSV)\n",
+    "print(f'Total runs: {len(df)}')\n",
+    "print(f'Models: {df.model.nunique()}')\n",
+    "print(f'Attacks: {df.attack.nunique()}')\n",
+    "df.head()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8beccbfc",
+   "metadata": {},
+   "source": [
+    "## Attack Success Rate (ASR) Table\n",
+    "Aggregated by model × attack, averaged over all epsilons, seeds, and images."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "80764de3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "asr_table = df.groupby(['model', 'attack'])['asr'].mean().unstack(fill_value=0) * 100\n",
+    "asr_table = asr_table.round(1)\n",
+    "print(asr_table.to_string())\n",
+    "\n",
+    "# Save LaTeX\n",
+    "latex = asr_table.to_latex(caption='Attack Success Rate (\\\\%) by model and attack method.',\n",
+    "                           label='tab:asr', float_format='%.1f')\n",
+    "with open(TABLES_DIR / 'asr_table.tex', 'w') as f:\n",
+    "    f.write(latex)\n",
+    "print('Saved to', TABLES_DIR / 'asr_table.tex')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fcb957ed",
+   "metadata": {},
+   "source": [
+    "## Image Quality Metrics vs. Epsilon"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "37fe9b55",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "metrics = ['ssim', 'psnr', 'l2', 'linf']\n",
+    "fig, axes = plt.subplots(1, len(metrics), figsize=(4*len(metrics), 3.5), sharey=False)\n",
+    "\n",
+    "for ax, metric in zip(axes, metrics):\n",
+    "    pivot = df.groupby(['epsilon', 'attack'])[metric].mean().unstack()\n",
+    "    pivot.plot(ax=ax, marker='o', linewidth=1.5)\n",
+    "    ax.set_title(metric.upper())\n",
+    "    ax.set_xlabel('Epsilon')\n",
+    "    ax.legend(fontsize=8)\n",
+    "    ax.grid(True, alpha=0.3)\n",
+    "\n",
+    "fig.tight_layout()\n",
+    "fig.savefig(FIGURES_DIR / 'quality_vs_epsilon.pdf', bbox_inches='tight')\n",
+    "fig.savefig(FIGURES_DIR / 'quality_vs_epsilon.png', dpi=200, bbox_inches='tight')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2497bb54",
+   "metadata": {},
+   "source": [
+    "## Attention Shift Metrics (JSD, Cosine Similarity)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "704c9f89",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "attn_metrics = ['jsd', 'cosine_similarity']\n",
+    "fig, axes = plt.subplots(1, 2, figsize=(10, 4))\n",
+    "\n",
+    "for ax, metric in zip(axes, attn_metrics):\n",
+    "    pivot = df.groupby(['epsilon', 'attack'])[metric].mean().unstack()\n",
+    "    pivot.plot(ax=ax, marker='s', linewidth=1.5)\n",
+    "    ax.set_title(f'Attention {metric.replace(\"_\", \" \").title()} vs. Epsilon')\n",
+    "    ax.set_xlabel('Epsilon')\n",
+    "    ax.legend(fontsize=8)\n",
+    "    ax.grid(True, alpha=0.3)\n",
+    "\n",
+    "fig.tight_layout()\n",
+    "fig.savefig(FIGURES_DIR / 'attention_shift.pdf', bbox_inches='tight')\n",
+    "fig.savefig(FIGURES_DIR / 'attention_shift.png', dpi=200, bbox_inches='tight')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dd58cfdc",
+   "metadata": {},
+   "source": [
+    "## Comprehensive Summary Table (for paper)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "64583c52",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "summary_cols = ['asr', 'confidence_drop', 'linf', 'l2', 'ssim', 'psnr', 'jsd', 'cosine_similarity']\n",
+    "summary = df.groupby(['model', 'attack'])[summary_cols].agg(['mean', 'std'])\n",
+    "\n",
+    "# Flatten multi-level columns\n",
+    "summary.columns = [f'{col}_{stat}' for col, stat in summary.columns]\n",
+    "summary = summary.round(4)\n",
+    "\n",
+    "# Save\n",
+    "summary.to_csv(TABLES_DIR / 'summary_stats.csv')\n",
+    "print('Saved summary to', TABLES_DIR / 'summary_stats.csv')\n",
+    "summary"
+   ]
+  }
+ ],
+ "metadata": {
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

notebooks/02-attention-figures.ipynb

@@ -0,0 +1,117 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "54561e91",
+   "metadata": {},
+   "source": [
+    "# ViTViz - Attention Figures\n",
+    "\n",
+    "Load saved attention maps (`.npy`) from `results/raw/attention/` and create comparison figures for the paper."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1641faab",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import matplotlib\n",
+    "matplotlib.rcParams.update({'font.size': 11, 'font.family': 'serif'})\n",
+    "\n",
+    "from pathlib import Path\n",
+    "from PIL import Image\n",
+    "\n",
+    "ATTENTION_DIR = Path('../results/raw/attention')\n",
+    "FIGURES_DIR = Path('../results/figures')\n",
+    "FIGURES_DIR.mkdir(parents=True, exist_ok=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a95c211e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# List all analysis directories\n",
+    "analysis_dirs = sorted([d for d in ATTENTION_DIR.iterdir() if d.is_dir()])\n",
+    "print(f'Found {len(analysis_dirs)} analyses')\n",
+    "for d in analysis_dirs[:10]:\n",
+    "    summary = json.loads((d / 'summary.json').read_text())\n",
+    "    print(f'  {d.name}: {summary[\"orig_label\"]} → {summary[\"adv_label\"]}')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1b781fd5",
+   "metadata": {},
+   "source": [
+    "## Comparison Grid: Original vs. Adversarial Attention"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "78fa078a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot_comparison_grid(dirs, ncols=4, save_path=None):\n",
+    "    \"\"\"Create a grid comparing original vs adversarial attention.\"\"\"\n",
+    "    nrows = len(dirs)\n",
+    "    fig, axes = plt.subplots(nrows, ncols, figsize=(ncols*3, nrows*3))\n",
+    "    if nrows == 1:\n",
+    "        axes = axes[np.newaxis, :]\n",
+    "\n",
+    "    col_titles = ['Original', 'Attn (Original)', 'Adversarial', 'Attn (Adversarial)']\n",
+    "\n",
+    "    for row, d in enumerate(dirs):\n",
+    "        summary = json.loads((d / 'summary.json').read_text())\n",
+    "\n",
+    "        orig = Image.open(d / 'original.png')\n",
+    "        orig_rollout = np.load(d / 'original_rollout.npy')\n",
+    "        adv = Image.open(d / 'adversarial.png')\n",
+    "        adv_rollout = np.load(d / 'adversarial_rollout.npy')\n",
+    "\n",
+    "        axes[row, 0].imshow(orig)\n",
+    "        axes[row, 0].set_ylabel(f'{summary[\"attack\"]}\\nε={summary[\"epsilon\"]:.4f}', fontsize=9)\n",
+    "\n",
+    "        axes[row, 1].imshow(orig_rollout, cmap='jet')\n",
+    "        axes[row, 1].set_title(summary['orig_label'] if row == 0 else '', fontsize=9)\n",
+    "\n",
+    "        axes[row, 2].imshow(adv)\n",
+    "\n",
+    "        axes[row, 3].imshow(adv_rollout, cmap='jet')\n",
+    "        axes[row, 3].set_title(summary['adv_label'] if row == 0 else '', fontsize=9)\n",
+    "\n",
+    "        for c in range(ncols):\n",
+    "            axes[row, c].axis('off')\n",
+    "            if row == 0:\n",
+    "                axes[row, c].set_title(col_titles[c], fontsize=10, fontweight='bold')\n",
+    "\n",
+    "    fig.tight_layout()\n",
+    "    if save_path:\n",
+    "        fig.savefig(save_path, dpi=300, bbox_inches='tight')\n",
+    "    plt.show()\n",
+    "\n",
+    "# Plot first 5 (or all if fewer)\n",
+    "plot_comparison_grid(\n",
+    "    analysis_dirs[:5],\n",
+    "    save_path=FIGURES_DIR / 'attention_comparison_grid.pdf'\n",
+    ")"
+   ]
+  }
+ ],
+ "metadata": {
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

requirements.txt

@@ -9,4 +9,13 @@ matplotlib>=3.7.0
 Pillow>=10.0.0
 huggingface_hub>=0.20.0
 transformers>=4.36.0
-safetensors>=0.4.0
+safetensors>=0.4.0
+
+# Metrics
+pytorch-msssim>=1.0.0
+lpips>=0.1.4
+
+# Experiment infrastructure
+pyyaml>=6.0
+tqdm>=4.60.0
+pandas>=2.0.0

utils/attacks.py

@@ -23,6 +23,13 @@ try:
 except Exception:  # pragma: no cover - optional dependency
     hf_hub_download = None
 
+try:
+    import cv2
+except Exception:  # pragma: no cover - optional for SAGA rollout resizing
+    cv2 = None
+
+from utils.visualization import attention_rollout
+
 def capture_outputs_and_attentions(model, x_norm: torch.Tensor):
     """Executa um forward único capturando atenções via hooks nas camadas de atenção do ViT.
     Retorna (outputs, attentions_list) onde attentions_list é lista de tensores [B,H,T,T] por camada.
@@ -106,8 +113,9 @@ class FGSM(torchattacks.FGSM):
     
     FGSM é um ataque de 1 única iteração (non-iterative).
     """
-    def __init__(self, model, eps=0.03):
+    def __init__(self, model, eps=0.03, collect_images: bool = True):
         super().__init__(model, eps=eps)
+        self.collect_images = collect_images
         self.iteration_images: List[Image.Image] = []
         self.iteration_tensors: List[torch.Tensor] = []
         # Atenções por iteração (iteração 0: original, iteração 1: adversarial)
@@ -135,14 +143,17 @@ class FGSM(torchattacks.FGSM):
         self.attentions_per_iter = []
         
         # Salvar imagem original
-        pil_img_orig = tensor_to_pil(images_denorm[0], denormalize=False)
-        self.iteration_images.append(pil_img_orig)
-        self.iteration_tensors.append(images.clone().detach())
+        if self.collect_images:
+            pil_img_orig = tensor_to_pil(images_denorm[0], denormalize=False)
+            self.iteration_images.append(pil_img_orig)
+            self.iteration_tensors.append(images.clone().detach())
         
         # Calcular gradiente
         images.requires_grad = True
         # Capturar atenções e logits para imagem original
         outputs, attentions0 = capture_outputs_and_attentions(self.model, images)
+        if isinstance(outputs, tuple):
+            outputs = outputs[0]
         self.attentions_per_iter.append([att for att in attentions0])
         
         if self.targeted:
@@ -162,9 +173,10 @@ class FGSM(torchattacks.FGSM):
         adv_images = (adv_images_denorm - mean) / std
         
         # Salvar imagem adversarial
-        pil_img_adv = tensor_to_pil(adv_images_denorm[0], denormalize=False)
-        self.iteration_images.append(pil_img_adv)
-        self.iteration_tensors.append(adv_images.clone().detach())
+        if self.collect_images:
+            pil_img_adv = tensor_to_pil(adv_images_denorm[0], denormalize=False)
+            self.iteration_images.append(pil_img_adv)
+            self.iteration_tensors.append(adv_images.clone().detach())
 
         # Capturar atenções para imagem adversarial final
         outputs_adv, attentions1 = capture_outputs_and_attentions(self.model, adv_images)
@@ -177,9 +189,10 @@ class PGDIterations(torchattacks.PGD):
     Extensão do ataque PGD padrão que captura e retorna
     as imagens adversariais de cada iteração como lista de PIL Images.
     """
-    def __init__(self, model, eps=0.05, alpha=0.005, steps=10, random_start=True):
+    def __init__(self, model, eps=0.05, alpha=0.005, steps=10, random_start=True, collect_images: bool = True):
         # Inicializa PGD padrão com os parâmetros
         super().__init__(model, eps=eps, alpha=alpha, steps=steps, random_start=random_start)
+        self.collect_images = collect_images
         self.iteration_images: List[Image.Image] = []
         self.iteration_tensors: List[torch.Tensor] = []
         self.attentions_per_iter: List[List[torch.Tensor]] = []
@@ -220,9 +233,10 @@ class PGDIterations(torchattacks.PGD):
         self.attentions_per_iter = []
         
         # Salvar iteração 0 (imagem original)
-        pil_img_orig = tensor_to_pil(images_denorm[0], denormalize=False)
-        self.iteration_images.append(pil_img_orig)
-        self.iteration_tensors.append(images.clone().detach())
+        if self.collect_images:
+            pil_img_orig = tensor_to_pil(images_denorm[0], denormalize=False)
+            self.iteration_images.append(pil_img_orig)
+            self.iteration_tensors.append(images.clone().detach())
         # Atenções da imagem original
         outputs0, attentions0 = capture_outputs_and_attentions(self.model, images)
         self.attentions_per_iter.append([att for att in attentions0])
@@ -232,6 +246,8 @@ class PGDIterations(torchattacks.PGD):
             adv_images = (adv_images_denorm - mean) / std
             adv_images.requires_grad = True
             outputs, attentions = capture_outputs_and_attentions(self.model, adv_images)
+            if isinstance(outputs, tuple):
+                outputs = outputs[0]
 
             # Calculate loss
             if self.targeted:
@@ -253,9 +269,10 @@ class PGDIterations(torchattacks.PGD):
             adv_images_normalized = (adv_images_denorm - mean) / std
             
             # Capturar imagem e tensor desta iteração
-            pil_img = tensor_to_pil(adv_images_denorm[0], denormalize=False)
-            self.iteration_images.append(pil_img)
-            self.iteration_tensors.append(adv_images_normalized.clone().detach())
+            if self.collect_images:
+                pil_img = tensor_to_pil(adv_images_denorm[0], denormalize=False)
+                self.iteration_images.append(pil_img)
+                self.iteration_tensors.append(adv_images_normalized.clone().detach())
             # Atenções desta iteração
             self.attentions_per_iter.append([att for att in attentions])
 
@@ -277,7 +294,8 @@ class SAGA(torch.nn.Module):
 
     def __init__(self, model, eps=8/255, steps=10, discard_ratio: float = 0.0,
                  head_fusion: str = "mean", use_resnet: bool = False,
-                 cnn_checkpoint_path: str = "resnet.pth", vit_weight=0.5):
+                 cnn_checkpoint_path: str = "resnet.pth", vit_weight=0.5,
+                 collect_images: bool = True):
         """Implementação correta do SAGA baseada no código original (SelfAttentionGradientAttack).
 
         Parâmetros:
@@ -288,9 +306,11 @@ class SAGA(torch.nn.Module):
         - head_fusion: estratégia de fusão de heads ('mean','max','min')
         - use_resnet: se True, acumula gradiente de um backbone CNN externo e o mistura ao gradiente ponderado pela atenção
         - cnn_checkpoint_path: caminho padrão do backbone CNN auxiliar (será carregado sob demanda)
+        - collect_images: se True, salva imagens PIL e tensores intermediários (necessário para UI)
         """
         super().__init__()
         self.model = model
+        self.collect_images = collect_images
         self.eps = eps
         self.steps = steps
         self.eps_step = self.eps / max(1, steps)
@@ -367,45 +387,6 @@ class SAGA(torch.nn.Module):
         # e serão passadas externamente; mantida para compatibilidade se necessário.
         raise RuntimeError("_attention_map should not be called directly; use integrated forward attention capture.")
 
-    def _capture_outputs_and_attentions(self, x_norm: torch.Tensor):
-        """Executa um forward único capturando atenções via hooks nas camadas de atenção do ViT.
-        Retorna (outputs, attentions_list) onde attentions_list é lista de tensores [B,H,T,T] por camada.
-        """
-        attentions: List[torch.Tensor] = []
-
-        def make_attention_hook():
-            def hook(module, input, output):
-                # input[0] é o embedding antes de atenção (B, N, C)
-                x = input[0]
-                B, N, C = x.shape
-                if not (hasattr(module, 'qkv') and hasattr(module, 'num_heads')):
-                    return
-                qkv = module.qkv(x).reshape(B, N, 3, module.num_heads, C // module.num_heads).permute(2, 0, 3, 1, 4)
-                q, k, v = qkv.unbind(0)
-                scale = (C // module.num_heads) ** -0.5
-                attn = (q @ k.transpose(-2, -1)) * scale
-                attn = attn.softmax(dim=-1)
-                attentions.append(attn.detach())
-            return hook
-
-        hooks = []
-        if not hasattr(self.model, 'blocks'):
-            outputs = self.model(x_norm)
-            return outputs, []
-        for block in self.model.blocks:
-            if hasattr(block, 'attn'):
-                hooks.append(block.attn.register_forward_hook(make_attention_hook()))
-
-        self.model.eval()
-        outputs = self.model(x_norm)
-
-        for h in hooks:
-            h.remove()
-
-        # mover atenções para CPU para cache leve
-        attentions = [a.cpu() for a in attentions]
-        return outputs, attentions
-
     def _load_cnn_backbone(self) -> Optional[torch.nn.Module]:
         """Carrega (lazy) o backbone CNN auxiliar usado quando use_resnet=True."""
         if not self.use_resnet:
@@ -518,15 +499,14 @@ class SAGA(torch.nn.Module):
         self.attentions_per_iter = []
 
         # Iteração 0 (imagem original)
-        self.iteration_images.append(tensor_to_pil(images_denorm[0], denormalize=False))
-        self.iteration_tensors.append(images.clone().detach())
+        if self.collect_images:
+            self.iteration_images.append(tensor_to_pil(images_denorm[0], denormalize=False))
+            self.iteration_tensors.append(images.clone().detach())
         # Atenção da imagem original: captura integrada
-        outputs0, attentions0 = self._capture_outputs_and_attentions(images)
+        outputs0, attentions0 = capture_outputs_and_attentions(self.model, images)
         # Guardar atenções brutas
         self.attentions_per_iter.append([att for att in attentions0])
         # Gerar máscara de rollout para cache visual
-        from utils.visualization import attention_rollout
-        import cv2
         b, _, h, w = images.shape
         mask0 = attention_rollout(attentions0, discard_ratio=self.discard_ratio, head_fusion=self.head_fusion)
         mask0_resized = cv2.resize(mask0, (w, h))
@@ -536,7 +516,7 @@ class SAGA(torch.nn.Module):
             # Normalizar para forward
             adv_norm = (adv_denorm - mean) / std
             adv_norm.requires_grad = True
-            outputs, attentions = self._capture_outputs_and_attentions(adv_norm)
+            outputs, attentions = capture_outputs_and_attentions(self.model, adv_norm)
             if isinstance(outputs, tuple):  # compatibilidade com modelos que retornam extras
                 outputs = outputs[0]
             loss = self.loss_fn(outputs, labels)
@@ -572,8 +552,9 @@ class SAGA(torch.nn.Module):
             adv_denorm = torch.clamp(images_denorm + delta, 0.0, 1.0).detach()
 
             # Salvar artefatos desta iteração
-            self.iteration_images.append(tensor_to_pil(adv_denorm[0], denormalize=False))
-            self.iteration_tensors.append(((adv_denorm - mean) / std).clone().detach())
+            if self.collect_images:
+                self.iteration_images.append(tensor_to_pil(adv_denorm[0], denormalize=False))
+                self.iteration_tensors.append(((adv_denorm - mean) / std).clone().detach())
 
         # Retorna tensor normalizado final
         adv_final = (adv_denorm - mean) / std
@@ -708,8 +689,9 @@ class MIFGSM(torchattacks.MIFGSM):
     Paper: "Boosting Adversarial Attacks with Momentum" (2017)
     https://arxiv.org/abs/1710.06081
     """
-    def __init__(self, model, eps=8/255, alpha=2/255, steps=10, decay=1.0):
+    def __init__(self, model, eps=8/255, alpha=2/255, steps=10, decay=1.0, collect_images: bool = True):
         super().__init__(model, eps=eps, alpha=alpha, steps=steps, decay=decay)
+        self.collect_images = collect_images
         self.iteration_images: List[Image.Image] = []
         self.iteration_tensors: List[torch.Tensor] = []
         self.attentions_per_iter: List[List[torch.Tensor]] = []
@@ -744,9 +726,10 @@ class MIFGSM(torchattacks.MIFGSM):
         self.attentions_per_iter = []
 
         # Salvar imagem original (iteração 0)
-        pil_img_orig = tensor_to_pil(images_denorm[0], denormalize=False)
-        self.iteration_images.append(pil_img_orig)
-        self.iteration_tensors.append(images.clone().detach())
+        if self.collect_images:
+            pil_img_orig = tensor_to_pil(images_denorm[0], denormalize=False)
+            self.iteration_images.append(pil_img_orig)
+            self.iteration_tensors.append(images.clone().detach())
 
         # Atenções da imagem original
         outputs0, attentions0 = capture_outputs_and_attentions(self.model, images)
@@ -757,6 +740,8 @@ class MIFGSM(torchattacks.MIFGSM):
             adv_images = (adv_images_denorm - mean) / std
             adv_images.requires_grad = True
             outputs, attentions = capture_outputs_and_attentions(self.model, adv_images)
+            if isinstance(outputs, tuple):
+                outputs = outputs[0]
 
             # Calcular loss
             if self.targeted:
@@ -786,9 +771,10 @@ class MIFGSM(torchattacks.MIFGSM):
 
             # Normalizar e armazenar artefatos desta iteração
             adv_images_normalized = (adv_images_denorm - mean) / std
-            self.iteration_tensors.append(adv_images_normalized.clone().detach())
-            pil_iter = tensor_to_pil(adv_images_denorm[0], denormalize=False)
-            self.iteration_images.append(pil_iter)
+            if self.collect_images:
+                self.iteration_tensors.append(adv_images_normalized.clone().detach())
+                pil_iter = tensor_to_pil(adv_images_denorm[0], denormalize=False)
+                self.iteration_images.append(pil_iter)
 
         adv_images = (adv_images_denorm - mean) / std
 
@@ -827,9 +813,11 @@ class TGR(torch.nn.Module):
         debug_stats: bool = False,
         protect_cls_token: bool = True,
         debug_progress: bool = False,
+        collect_images: bool = True,
     ) -> None:
         super().__init__()
         self.model = model
+        self.collect_images = collect_images
         self.eps = float(eps)
         self.steps = int(steps)
         self.decay = float(decay)
@@ -1196,8 +1184,9 @@ class TGR(torch.nn.Module):
         self.debug_progress_log = []
 
         # Iteração 0 (imagem original)
-        self.iteration_images.append(tensor_to_pil(images_denorm[0], denormalize=False))
-        self.iteration_tensors.append(images.clone().detach())
+        if self.collect_images:
+            self.iteration_images.append(tensor_to_pil(images_denorm[0], denormalize=False))
+            self.iteration_tensors.append(images.clone().detach())
         
         # Garantir eval mode (evita dropout/ruído durante ataque)
         was_training = self.model.training
@@ -1317,9 +1306,10 @@ class TGR(torch.nn.Module):
                     print(f"[TGR DEBUG] Iteration delta: {actual_delta:.6f} (eps={self.eps:.6f}, eps_step={self.eps_step:.6f})")
 
                 # Salvar artefatos desta iteração
-                adv_denorm = torch.clamp(unnorm_inps + perts, 0.0, 1.0).detach()
-                self.iteration_images.append(tensor_to_pil(adv_denorm[0], denormalize=False))
-                self.iteration_tensors.append(((adv_denorm - mean) / std).clone().detach())
+                if self.collect_images:
+                    adv_denorm = torch.clamp(unnorm_inps + perts, 0.0, 1.0).detach()
+                    self.iteration_images.append(tensor_to_pil(adv_denorm[0], denormalize=False))
+                    self.iteration_tensors.append(((adv_denorm - mean) / std).clone().detach())
 
         finally:
             for h in handles:

utils/metrics.py

@@ -0,0 +1,255 @@
+"""Evaluation metrics for adversarial attack analysis.
+
+All functions accept pure tensors and return Python floats.
+No UI or Gradio dependency.
+
+Metric groups:
+  - Image quality: SSIM, PSNR, LPIPS, L2, L-inf
+  - Attack success: ASR, confidence drop, top-k accuracy drop
+
+Usage:
+    from utils.metrics import compute_all_image_metrics, compute_all_attack_metrics
+"""
+
+import math
+from typing import Dict, Optional, Tuple
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+
+
+# ---------------------------------------------------------------------------
+# ImageNet denormalization (shared constant)
+# ---------------------------------------------------------------------------
+IMAGENET_MEAN = torch.tensor([0.485, 0.456, 0.406]).view(1, 3, 1, 1)
+IMAGENET_STD = torch.tensor([0.229, 0.224, 0.225]).view(1, 3, 1, 1)
+
+
+def _to_01(x: torch.Tensor) -> torch.Tensor:
+    """Denormalize ImageNet tensor to [0, 1] range.
+
+    If already in [0,1] (min>=0, max<=1) returns as-is.
+    """
+    if x.min() < -0.1:  # heuristic: normalized images have negative values
+        mean = IMAGENET_MEAN.to(x.device)
+        std = IMAGENET_STD.to(x.device)
+        x = x * std + mean
+    return x.clamp(0, 1)
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# Image Quality Metrics
+# ═══════════════════════════════════════════════════════════════════════════
+
+def compute_linf(orig: torch.Tensor, adv: torch.Tensor) -> float:
+    """L-infinity distance in [0,1] space.
+
+    Args:
+        orig: Original image tensor (BxCxHxW or CxHxW), normalized or [0,1].
+        adv:  Adversarial image tensor, same shape.
+
+    Returns:
+        Maximum absolute pixel difference in [0,1] space.
+    """
+    o = _to_01(orig)
+    a = _to_01(adv)
+    return (o - a).abs().max().item()
+
+
+def compute_psnr(orig: torch.Tensor, adv: torch.Tensor) -> float:
+    """Peak Signal-to-Noise Ratio (dB) in [0,1] space.
+
+    Higher = less distortion. Returns inf if images are identical.
+    """
+    o = _to_01(orig)
+    a = _to_01(adv)
+    mse = F.mse_loss(o, a).item()
+    if mse < 1e-10:
+        return float("inf")
+    return 10.0 * math.log10(1.0 / mse)
+
+
+def compute_ssim(orig: torch.Tensor, adv: torch.Tensor) -> float:
+    """Structural Similarity Index (SSIM).
+
+    Requires pytorch-msssim. Returns value in [-1, 1], higher = more similar.
+    """
+    try:
+        from pytorch_msssim import ssim
+    except ImportError:
+        raise ImportError(
+            "pytorch-msssim is required for SSIM. "
+            "Install: pip install pytorch-msssim"
+        )
+    o = _to_01(orig)
+    a = _to_01(adv)
+    # Ensure 4D (BxCxHxW)
+    if o.dim() == 3:
+        o = o.unsqueeze(0)
+    if a.dim() == 3:
+        a = a.unsqueeze(0)
+    return ssim(o, a, data_range=1.0, size_average=True).item()
+
+
+def compute_lpips(orig: torch.Tensor, adv: torch.Tensor,
+                  net: str = "alex",
+                  _lpips_cache: dict = {}) -> float:
+    """Learned Perceptual Image Patch Similarity (LPIPS).
+
+    Lower = more similar. Uses AlexNet by default (fastest).
+    The LPIPS model is cached across calls.
+
+    Args:
+        orig: Original image tensor.
+        adv:  Adversarial image tensor.
+        net:  Backbone network ('alex', 'vgg', 'squeeze').
+
+    Returns:
+        LPIPS distance (lower = more perceptually similar).
+    """
+    try:
+        import lpips as lpips_lib
+    except ImportError:
+        raise ImportError(
+            "lpips is required for LPIPS metric. "
+            "Install: pip install lpips"
+        )
+
+    cache_key = net
+    if cache_key not in _lpips_cache:
+        _lpips_cache[cache_key] = lpips_lib.LPIPS(net=net, verbose=False)
+
+    loss_fn = _lpips_cache[cache_key]
+
+    o = _to_01(orig)
+    a = _to_01(adv)
+
+    # LPIPS expects [-1, 1] range
+    o_scaled = o * 2.0 - 1.0
+    a_scaled = a * 2.0 - 1.0
+
+    if o_scaled.dim() == 3:
+        o_scaled = o_scaled.unsqueeze(0)
+    if a_scaled.dim() == 3:
+        a_scaled = a_scaled.unsqueeze(0)
+
+    device = o_scaled.device
+    loss_fn = loss_fn.to(device)
+
+    with torch.no_grad():
+        dist = loss_fn(o_scaled, a_scaled)
+
+    return dist.item()
+
+
+def compute_modified_pixels(orig: torch.Tensor, adv: torch.Tensor,
+                            threshold: float = 1e-5) -> float:
+    """Fraction of pixels modified by the attack (0 to 1)."""
+    o = _to_01(orig)
+    a = _to_01(adv)
+    diff = (o - a).abs().max(dim=-3)[0]  # max over channels
+    return (diff > threshold).float().mean().item()
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# Attack Success Metrics
+# ═══════════════════════════════════════════════════════════════════════════
+
+def compute_asr(orig_pred: int, adv_pred: int) -> float:
+    """Attack Success Rate for a single sample.
+
+    Returns 1.0 if attack changed the prediction, 0.0 otherwise.
+    For batch ASR, average across samples.
+    """
+    return 1.0 if orig_pred != 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.
+
+    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.
+
+    Returns:
+        Drop in confidence (positive = confidence decreased).
+    """
+    return (orig_probs[orig_label] - adv_probs[orig_label]).item()
+
+
+def compute_topk_drop(orig_probs: torch.Tensor,
+                      adv_probs: torch.Tensor,
+                      orig_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.
+    """
+    _, adv_topk = torch.topk(adv_probs, min(k, len(adv_probs)))
+    return 0.0 if orig_label in adv_topk.tolist() else 1.0
+
+
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# Aggregate Helper
+# ═══════════════════════════════════════════════════════════════════════════
+
+def compute_all_image_metrics(
+    orig: torch.Tensor,
+    adv: torch.Tensor,
+    use_lpips: bool = True,
+) -> Dict[str, float]:
+    """Compute all image quality metrics at once.
+
+    Args:
+        orig: Original image tensor (BxCxHxW or CxHxW).
+        adv:  Adversarial image tensor.
+        use_lpips: Whether to compute LPIPS (requires lpips package).
+
+    Returns:
+        Dictionary with keys: linf, psnr, ssim, lpips, modified_pixels.
+    """
+    results = {
+        "linf": compute_linf(orig, adv),
+        "psnr": compute_psnr(orig, adv),
+        "ssim": compute_ssim(orig, adv),
+        "modified_pixels": compute_modified_pixels(orig, adv),
+    }
+
+    if use_lpips:
+        try:
+            results["lpips"] = compute_lpips(orig, adv)
+        except ImportError:
+            results["lpips"] = float("nan")
+    else:
+        results["lpips"] = float("nan")
+
+    return results
+
+
+def compute_all_attack_metrics(
+    orig_probs: torch.Tensor,
+    adv_probs: torch.Tensor,
+    orig_label: int,
+    adv_label: int,
+    k: int = 5,
+) -> Dict[str, float]:
+    """Compute all attack success metrics at once.
+
+    Returns:
+        Dictionary with keys: asr, confidence_drop, topk_drop.
+    """
+    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),
+    }
+
+    return results
+

utils/model_loader.py

@@ -338,6 +338,26 @@ def _convert_hf_vit_to_timm_state_dict(hf_sd: Dict[str, torch.Tensor], num_layer
     return out
 
 
+def _convert_hf_timm_wrapper_to_timm_state_dict(hf_sd: Dict[str, torch.Tensor]) -> Dict[str, torch.Tensor]:
+    """Converte state_dict de TimmWrapper (Transformers) para formato timm ViT.
+
+    Exemplo de origem: chaves com prefixo ``timm_model.``.
+    """
+    out: Dict[str, torch.Tensor] = {}
+
+    for key, value in hf_sd.items():
+        if key.startswith("timm_model."):
+            out[key[len("timm_model."):]] = value
+        elif key.startswith("classifier."):
+            # Alguns wrappers usam head separado como classifier.
+            out[f"head.{key[len('classifier.'):]}"] = value
+
+    if not out:
+        raise ValueError("State_dict de TimmWrapper sem chaves reconhecidas (timm_model.* / classifier.*).")
+
+    return out
+
+
 def load_vit_from_huggingface(model_id: str, device: Optional[torch.device] = None) -> Tuple[torch.nn.Module, Optional[Dict[int, str]], ViTConfig]:
     """Carrega ViT do Hugging Face Hub e retorna um modelo timm equivalente.
     
@@ -351,37 +371,27 @@ def load_vit_from_huggingface(model_id: str, device: Optional[torch.device] = No
     hf_model = AutoModelForImageClassification.from_pretrained(model_id)
     hf_model.eval()
     cfg = getattr(hf_model, "config", None)
-    num_labels = int(getattr(cfg, "num_labels", 1000)) if cfg is not None else 1000
-    num_layers = int(getattr(cfg, "num_hidden_layers", 12)) if cfg is not None else 12
-    hidden_size = int(getattr(cfg, "hidden_size", 768)) if cfg is not None else 768
-    num_heads = int(getattr(cfg, "num_attention_heads", 12)) if cfg is not None else 12
-    patch_size = int(getattr(cfg, "patch_size", 16)) if cfg is not None else 16
-    img_size = int(getattr(cfg, "image_size", 224)) if cfg is not None else 224
-    intermediate_size = int(getattr(cfg, "intermediate_size", hidden_size * 4)) if cfg is not None else hidden_size * 4
-    qkv_bias = bool(getattr(cfg, "qkv_bias", True)) if cfg is not None else True
     class_names = _hf_id2label_to_class_names(getattr(cfg, "id2label", None)) if cfg is not None else None
 
-    # Criar config dinâmico
-    vit_config = ViTConfig(
-        embed_dim=hidden_size,
-        num_heads=num_heads,
-        num_layers=num_layers,
-        patch_size=patch_size,
-        img_size=img_size,
-        num_classes=num_labels,
-        mlp_ratio=intermediate_size / hidden_size,
-        qkv_bias=qkv_bias
-    )
-    
+    hf_sd = hf_model.state_dict()
+    if any(key.startswith("timm_model.") for key in hf_sd.keys()):
+        timm_sd = _convert_hf_timm_wrapper_to_timm_state_dict(hf_sd)
+    else:
+        num_layers = int(getattr(cfg, "num_hidden_layers", 12)) if cfg is not None else 12
+        timm_sd = _convert_hf_vit_to_timm_state_dict(hf_sd, num_layers=num_layers)
+
+    vit_config = infer_config_from_state_dict(timm_sd)
+    if cfg is not None and hasattr(cfg, "num_labels"):
+        try:
+            vit_config.num_classes = int(getattr(cfg, "num_labels"))
+        except Exception:
+            pass
+
     print(f"[ViTViz] Carregando do HuggingFace: {vit_config.timm_model_name} "
           f"(embed_dim={vit_config.embed_dim}, heads={vit_config.num_heads}, "
-          f"layers={vit_config.num_layers})")
-    
-    # Criar modelo com arquitetura customizada diretamente
+          f"layers={vit_config.num_layers}, patch={vit_config.patch_size}, img={vit_config.img_size})")
+
     timm_model = create_vit_from_config(vit_config, device=device)
-    
-    # Converter e carregar state_dict
-    timm_sd = _convert_hf_vit_to_timm_state_dict(hf_model.state_dict(), num_layers=num_layers)
     timm_model.load_state_dict(timm_sd, strict=False)
     timm_model.eval()
     

utils/seed.py

@@ -0,0 +1,37 @@
+"""Seed management for reproducible experiments.
+
+Usage:
+    from utils.seed import set_seed
+    set_seed(42)
+"""
+
+import os
+import random
+
+import numpy as np
+import torch
+
+
+def set_seed(seed: int = 42) -> None:
+    """Set all random seeds for reproducibility.
+
+    Fixes: random, numpy, torch (CPU + CUDA), cuDNN determinism,
+    and Python hash seed.
+
+    Note: even with all seeds set, GPU non-determinism may cause
+    small numerical differences across runs. See:
+    https://pytorch.org/docs/stable/notes/randomness.html
+
+    Args:
+        seed: Integer seed value.
+    """
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    os.environ["PYTHONHASHSEED"] = str(seed)
+
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed(seed)
+        torch.cuda.manual_seed_all(seed)
+        torch.backends.cudnn.deterministic = True
+        torch.backends.cudnn.benchmark = False