🚀 No Time to Train!

Segmentazione di istanza di riferimento senza addestramento

Stato dell’arte (Papers with Code) _SOTA 1-shot_ | -21CBCE?style=flat&logo=paperswithcode)

_SOTA 10-shot_ | -21CBCE?style=flat&logo=paperswithcode)

_SOTA 30-shot_ | -21CBCE?style=flat&logo=paperswithcode)

🚨 Aggiornamento (5 febbraio 2026): Il manoscritto dell’articolo è stato aggiornato con ampi studi di ablation, visualizzazioni ed esperimenti aggiuntivi.

🚨 Aggiornamento (22 luglio 2025): Sono state aggiunte istruzioni per dataset personalizzati!

🔔 Aggiornamento (16 luglio 2025): Il codice è stato aggiornato con le istruzioni!

📋 Indice

• 🎯 Punti Salienti
• 📜 Abstract
• 🧠 Architettura
• 🛠️ Istruzioni di installazione
• 1. Clona il repository
• 2. Crea ambiente conda
• 3. Installa SAM2 e DINOv2
• 4. Scarica i dataset
• 5. Scarica i checkpoint di SAM2 e DINOv2
• 📊 Codice di inferenza: Riproduci risultati SOTA 30-shot in Few-shot COCO
• 0. Crea set di riferimento
• 1. Riempi la memoria con riferimenti
• 2. Post-elabora la memoria
• 3. Inferenza sulle immagini target
• Risultati
• 🔍 Dataset personalizzato
• 0. Prepara un dataset personalizzato ⛵🐦
• 0.1 Se sono disponibili solo annotazioni bbox
• 0.2 Converti annotazioni coco in file pickle
• 1. Riempire la memoria con i riferimenti
• 2. Post-elaborare la memory bank
• 📚 Citazione

🎯 Punti salienti

• 💡 Senza Training: Nessun fine-tuning, nessun prompt engineering—solo un'immagine di riferimento.
• 🖼️ Basato su Riferimento: Segmenta nuovi oggetti usando solo pochi esempi.
• 🔥 Prestazioni SOTA: Supera i precedenti approcci senza training su COCO, PASCAL VOC e Cross-Domain FSOD.

• 🧾 Carta arXiv
• 🌐 Sito del Progetto
• 📈 Papers with Code

📜 Abstract

The performance of image segmentation models has historically been constrained by the high cost of collecting large-scale annotated data. The Segment Anything Model (SAM) alleviates this original problem through a promptable, semantics-agnostic, segmentation paradigm and yet still requires manual visual-prompts or complex domain-dependent prompt-generation rules to process a new image. Towards reducing this new burden, our work investigates the task of object segmentation when provided with, alternatively, only a small set of reference images. Our key insight is to leverage strong semantic priors, as learned by foundation models, to identify corresponding regions between a reference and a target image. We find that correspondences enable automatic generation of instance-level segmentation masks for downstream tasks and instantiate our ideas via a multi-stage, training-free method incorporating (1) memory bank construction; (2) representation aggregation and (3) semantic-aware feature matching. Our experiments show significant improvements on segmentation metrics, leading to state-of-the-art performance on COCO FSOD (36.8% nAP), PASCAL VOC Few-Shot (71.2% nAP50) and outperforming existing training-free approaches on the Cross-Domain FSOD benchmark (22.4% nAP).

🧠 Architecture

🛠️ Installation instructions

1. Clone the repository

git clone https://github.com/miquel-espinosa/no-time-to-train.git
cd no-time-to-train

2. Crea l'ambiente conda

Creeremo un ambiente conda con i pacchetti necessari.

conda env create -f environment.yml
conda activate no-time-to-train

3. Installa SAM2 e DINOv2

Installeremo SAM2 e DINOv2 dal sorgente.

pip install -e .
cd dinov2
pip install -e .
cd ..

4. Scarica i dataset

Per favore scarica il dataset COCO e posizionalo in data/coco

5. Scarica i checkpoint SAM2 e DINOv2

Scaricheremo gli stessi checkpoint SAM2 utilizzati nell'articolo. (Tieni presente, tuttavia, che i checkpoint SAM2.1 sono già disponibili e potrebbero offrire prestazioni migliori.)

mkdir -p checkpoints/dinov2
cd checkpoints
wget https://dl.fbaipublicfiles.com/segment_anything_2/072824/sam2_hiera_large.pt
cd dinov2
wget https://dl.fbaipublicfiles.com/dinov2/dinov2_vitl14/dinov2_vitl14_pretrain.pth
cd ../..

📊 Codice di inferenza

⚠️ Disclaimer: Questo è codice di ricerca — aspettatevi un po' di caos!

Riproduzione dei risultati SOTA a 30-shot su Few-shot COCO

Definire variabili utili e creare una cartella per i risultati:

CONFIG=./no_time_to_train/new_exps/coco_fewshot_10shot_Sam2L.yaml
CLASS_SPLIT="few_shot_classes"
RESULTS_DIR=work_dirs/few_shot_results
SHOTS=30
SEED=33
GPUS=4
mkdir -p $RESULTS_DIR
FILENAME=few_shot_${SHOTS}shot_seed${SEED}.pkl

python no_time_to_train/dataset/few_shot_sampling.py \
        --n-shot $SHOTS \
        --out-path ${RESULTS_DIR}/${FILENAME} \
        --seed $SEED \
        --dataset $CLASS_SPLIT

python run_lightening.py test --config $CONFIG \
                              --model.test_mode fill_memory \
                              --out_path ${RESULTS_DIR}/memory.ckpt \
                              --model.init_args.model_cfg.memory_bank_cfg.length $SHOTS \
                              --model.init_args.dataset_cfgs.fill_memory.memory_pkl ${RESULTS_DIR}/${FILENAME} \
                              --model.init_args.dataset_cfgs.fill_memory.memory_length $SHOTS \
                              --model.init_args.dataset_cfgs.fill_memory.class_split $CLASS_SPLIT \
                              --trainer.logger.save_dir ${RESULTS_DIR}/ \
                              --trainer.devices $GPUS

python run_lightening.py test --config $CONFIG \
                              --model.test_mode postprocess_memory \
                              --model.init_args.model_cfg.memory_bank_cfg.length $SHOTS \
                              --ckpt_path ${RESULTS_DIR}/memory.ckpt \
                              --out_path ${RESULTS_DIR}/memory_postprocessed.ckpt \
                              --trainer.devices 1

python run_lightening.py test --config $CONFIG  \
                              --ckpt_path ${RESULTS_DIR}/memory_postprocessed.ckpt \
                              --model.init_args.test_mode test \
                              --model.init_args.model_cfg.memory_bank_cfg.length $SHOTS \
                              --model.init_args.model_cfg.dataset_name $CLASS_SPLIT \
                              --model.init_args.dataset_cfgs.test.class_split $CLASS_SPLIT \
                              --trainer.logger.save_dir ${RESULTS_DIR}/ \
                              --trainer.devices $GPUS

    --model.init_args.model_cfg.test.online_vis True

    --model.init_args.model_cfg.test.vis_thr 0.4

Nota che in questo esempio stiamo usando lo split few_shot_classes, quindi dovremmo aspettarci di vedere solo le istanze segmentate delle classi presenti in questo split (non tutte le classi in COCO).

#### Risultati

Dopo aver elaborato tutte le immagini nel set di validazione, dovresti ottenere:

BBOX RESULTS:
  Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.368
SEGM RESULTS:
  Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.342

🔍 Dataset personalizzato

Forniamo le istruzioni per eseguire la nostra pipeline su un dataset personalizzato. Il formato delle annotazioni è sempre in formato COCO.

TLDR; Per vedere direttamente come eseguire la pipeline completa su dataset personalizzati, consulta scripts/matching_cdfsod_pipeline.sh insieme agli script di esempio dei dataset CD-FSOD (ad es. scripts/dior_fish.sh)

0. Prepara un dataset personalizzato ⛵🐦

Immaginiamo di voler rilevare barche⛵ e uccelli🐦 in un dataset personalizzato. Per utilizzare il nostro metodo avremo bisogno di:

• Almeno 1 immagine di riferimento annotata per ogni classe (cioè 1 immagine di riferimento per barca e 1 per uccello)
• Più immagini target in cui trovare le istanze delle classi desiderate.

mkdir -p data/my_custom_dataset
python scripts/make_custom_dataset.py

data/my_custom_dataset/
    ├── annotations/
    │   ├── custom_references.json
    │   ├── custom_targets.json
    │   └── references_visualisations/
    │       ├── bird_1.jpg
    │       └── boat_1.jpg
    └── images/
        ├── 429819.jpg
        ├── 101435.jpg
        └── (all target and reference images)

| Immagine di riferimento 1-shot per UCCELLO 🐦 | Immagine di riferimento 1-shot per BARCA ⛵ | |:--------------------------------------------:|:-------------------------------------------:| | | |

0.1 Se sono disponibili solo annotazioni bbox

Forniamo anche uno script per generare maschere di segmentazione a livello di istanza utilizzando SAM2. Questo è utile se sono disponibili solo annotazioni di bounding box per le immagini di riferimento.

# Download sam_h checkpoint. Feel free to use more recent checkpoints (note: code might need to be adapted)
wget https://dl.fbaipublicfiles.com/segment_anything/sam_vit_h_4b8939.pth -O checkpoints/sam_vit_h_4b8939.pth
Run automatic instance segmentation from ground truth bounding boxes.
python no_time_to_train/dataset/sam_bbox_to_segm_batch.py \
    --input_json data/my_custom_dataset/annotations/custom_references.json \
    --image_dir data/my_custom_dataset/images \
    --sam_checkpoint checkpoints/sam_vit_h_4b8939.pth \
    --model_type vit_h \
    --device cuda \
    --batch_size 8 \
    --visualize

La visualizzazione delle maschere di segmentazione generate è salvata in data/my_custom_dataset/annotations/custom_references_with_SAM_segm/references_visualisations/.

| Immagine di riferimento 1-shot per UCCELLO 🐦 (segmentata automaticamente con SAM) | Immagine di riferimento 1-shot per BARCA ⛵ (segmentata automaticamente con SAM) | |:---------------------------------:|:----------------------------------:| | | |

0.2 Convertire annotazioni coco in file pickle

python no_time_to_train/dataset/coco_to_pkl.py \
    data/my_custom_dataset/annotations/custom_references_with_segm.json \
    data/my_custom_dataset/annotations/custom_references_with_segm.pkl \
    1

1. Riempire la memoria con riferimenti

Per prima cosa, definire le variabili utili e creare una cartella per i risultati. Per una corretta visualizzazione delle etichette, i nomi delle classi devono essere ordinati in base all'id della categoria come appare nel file json. Ad esempio, bird ha id categoria 16, boat ha id categoria 9. Quindi, CAT_NAMES=boat,bird.

DATASET_NAME=my_custom_dataset
DATASET_PATH=data/my_custom_dataset
CAT_NAMES=boat,bird
CATEGORY_NUM=2
SHOT=1
YAML_PATH=no_time_to_train/pl_configs/matching_cdfsod_template.yaml
PATH_TO_SAVE_CKPTS=./tmp_ckpts/my_custom_dataset
mkdir -p $PATH_TO_SAVE_CKPTS

python run_lightening.py test --config $YAML_PATH \
    --model.test_mode fill_memory \
    --out_path $PATH_TO_SAVE_CKPTS/$DATASET_NAME\_$SHOT\_refs_memory.pth \
    --model.init_args.dataset_cfgs.fill_memory.root $DATASET_PATH/images \
    --model.init_args.dataset_cfgs.fill_memory.json_file $DATASET_PATH/annotations/custom_references_with_segm.json \
    --model.init_args.dataset_cfgs.fill_memory.memory_pkl $DATASET_PATH/annotations/custom_references_with_segm.pkl \
    --model.init_args.dataset_cfgs.fill_memory.memory_length $SHOT \
    --model.init_args.dataset_cfgs.fill_memory.cat_names $CAT_NAMES \
    --model.init_args.model_cfg.dataset_name $DATASET_NAME \
    --model.init_args.model_cfg.memory_bank_cfg.length $SHOT \
    --model.init_args.model_cfg.memory_bank_cfg.category_num $CATEGORY_NUM \
    --trainer.devices 1

2. Post-elaborazione della memoria di banco

python run_lightening.py test --config $YAML_PATH \
    --model.test_mode postprocess_memory \
    --ckpt_path $PATH_TO_SAVE_CKPTS/$DATASET_NAME\_$SHOT\_refs_memory.pth \
    --out_path $PATH_TO_SAVE_CKPTS/$DATASET_NAME\_$SHOT\_refs_memory_postprocessed.pth \
    --model.init_args.model_cfg.dataset_name $DATASET_NAME \
    --model.init_args.model_cfg.memory_bank_cfg.length $SHOT \
    --model.init_args.model_cfg.memory_bank_cfg.category_num $CATEGORY_NUM \
    --trainer.devices 1

#### 2.1 Visualizzare la memoria elaborata post-processo

python run_lightening.py test --config $YAML_PATH \
    --model.test_mode vis_memory \
    --ckpt_path $PATH_TO_SAVE_CKPTS/$DATASET_NAME\_$SHOT\_refs_memory_postprocessed.pth \
    --model.init_args.dataset_cfgs.fill_memory.root $DATASET_PATH/images \
    --model.init_args.dataset_cfgs.fill_memory.json_file $DATASET_PATH/annotations/custom_references_with_segm.json \
    --model.init_args.dataset_cfgs.fill_memory.memory_pkl $DATASET_PATH/annotations/custom_references_with_segm.pkl \
    --model.init_args.dataset_cfgs.fill_memory.memory_length $SHOT \
    --model.init_args.dataset_cfgs.fill_memory.cat_names $CAT_NAMES \
    --model.init_args.model_cfg.dataset_name $DATASET_NAME \
    --model.init_args.model_cfg.memory_bank_cfg.length $SHOT \
    --model.init_args.model_cfg.memory_bank_cfg.category_num $CATEGORY_NUM \
    --trainer.devices 1

3. Inferenza sulle immagini target

Se ONLINE_VIS è impostato su True, i risultati della predizione saranno salvati in results_analysis/my_custom_dataset/ e visualizzati man mano che vengono calcolati. NOTA che l’esecuzione con la visualizzazione online è molto più lenta.

Sentiti libero di modificare la soglia di punteggio VIS_THR per vedere più o meno istanze segmentate.

ONLINE_VIS=True
VIS_THR=0.4
python run_lightening.py test --config $YAML_PATH \
    --model.test_mode test \
    --ckpt_path $PATH_TO_SAVE_CKPTS/$DATASET_NAME\_$SHOT\_refs_memory_postprocessed.pth \
    --model.init_args.model_cfg.dataset_name $DATASET_NAME \
    --model.init_args.model_cfg.memory_bank_cfg.length $SHOT \
    --model.init_args.model_cfg.memory_bank_cfg.category_num $CATEGORY_NUM \
    --model.init_args.model_cfg.test.imgs_path $DATASET_PATH/images \
    --model.init_args.model_cfg.test.online_vis $ONLINE_VIS \
    --model.init_args.model_cfg.test.vis_thr $VIS_THR \
    --model.init_args.dataset_cfgs.test.root $DATASET_PATH/images \
    --model.init_args.dataset_cfgs.test.json_file $DATASET_PATH/annotations/custom_targets.json \
    --model.init_args.dataset_cfgs.test.cat_names $CAT_NAMES \
    --trainer.devices 1

Risultati

Le metriche di prestazione (con gli stessi parametri esatti dei comandi sopra) dovrebbero essere:

BBOX RESULTS:
  Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.478
SEGM RESULTS:
  Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.458

I risultati visivi sono salvati in results_analysis/my_custom_dataset/. Nota che il nostro metodo funziona per i falsi negativi, cioè immagini che non contengono alcuna istanza delle classi desiderate.

Clicca sulle immagini per ingrandire ⬇️

| Immagine target con barche ⛵ (sinistra GT, destra predizioni) | Immagine target con uccelli 🐦 (sinistra GT, destra predizioni) | |:----------------------:|:----------------------:| | | |

| Immagine target con barche e uccelli ⛵🐦 (sinistra GT, destra predizioni) | Immagine target senza barche o uccelli 🚫 (sinistra GT, destra predizioni) | |:---------------------------------:|:----------------------------------:| | | |

🔬 Ablazioni

Ablazione backbone

Per valutare la trasferibilità del nostro metodo tra modelli foundation, sostituiamo sia l'encoder semantico (DINOv2) che il segmentatore basato su SAM con diverse alternative.

Ablazione encoder semantico:

# CLIP (Sizes: b16, b32, l14, l14@336px)
bash scripts/clip/clipl14@336px.sh
bash scripts/clip/clipl14.sh
bash scripts/clip/clipb16.sh
bash scripts/clip/clipb32.sh
DINOV3 (Sizes: b, l, h)
bash scripts/dinov3/dinov3b.sh
bash scripts/dinov3/dinov3l.sh
bash scripts/dinov3/dinov3h.sh
PE (Sizes: g14, l14)
bash scripts/pe/PEg14.sh
bash scripts/pe/PEl14.sh

Ablazione del segmentatore:

# SAM2 (Sizes: tiny, small, base+, large)
bash scripts/sam2/sam2_tiny.sh
bash scripts/sam2/sam2_small.sh
bash scripts/sam2/sam2_base_plus.sh
bash scripts/baseline/dinov2_sam_baseline.sh # SAM2 Large

Valutazione VLM sul dataset COCO few-shot

Valutiamo QWEN VLM sul dataset COCO few-shot.

bash scripts/vl-qwen/ablation-vl-qwen.sh

Euristiche delle immagini di riferimento

Per capire perché immagini di riferimento diverse portano a variazioni nelle prestazioni, analizziamo le proprietà statistiche delle annotazioni delle classi nuove di COCO.

#### ANALISI

Studiamo tre caratteristiche delle annotazioni: (1) area della maschera (dimensione dell'oggetto), (2) posizione del centro della maschera e (3) distanza dai bordi dell'immagine.

# Mask area distribution
python no_time_to_train/make_plots/mask_area_distribution.py \
  --input data/coco/annotations/instances_val2017.json \
  --output no_time_to_train/make_plots/mask_area_distribution/mask_area_distribution.png \
  --edges-output no_time_to_train/make_plots/mask_area_distribution/bbox_edge_distance_histograms.png \
  --center-output no_time_to_train/make_plots/mask_area_distribution/bbox_center_density.png \
  --bins 80 \
  --distance-bins 80 \
  --disable-center-density
Bbox center positions
python no_time_to_train/make_plots/bbox_positions.py \
	--per-class-root data/coco/annotations/per_class_instances \
	--filename centeredness_2d_hist_plain.png \
	--max-cols 6 \
	--output-dir ./no_time_to_train/make_plots/bbox_positions \
	--outfile grid_bbox_positions.png

[OUTPUT] Distribuzione area maschera

[OUTPUT] Densità centro bbox

[OUTPUT] Istogrammi distanza bordo bbox

#### SELEZIONE

Campioniamo 100 immagini di riferimento diverse per classe, coprendo esplicitamente una gamma di dimensioni maschera, centri e distanze dai bordi. Ogni riferimento viene valutato su un sottoinsieme fisso e ridotto di validazione.

bash scripts/1shot_ref_ablation/setup.sh

# Example launch script that calls template script for each reference set
bash scripts/1shot_ref_ablation/gpu0.sh

#### RISULTATI

Analizziamo come i punteggi di rilevamento si correlano con le caratteristiche delle immagini di riferimento (dimensione della maschera, posizione del centro, distanza dal bordo).

python no_time_to_train/make_plots/heuristics_analysis.py
Outputs: 
- no_time_to_train/make_plots/heuristics_analysis/heatmap_bbox_norm_scores.png
- no_time_to_train/make_plots/heuristics_analysis/heatmap_segm_norm_scores.png
- no_time_to_train/make_plots/heuristics_analysis/heatmap_center_bbox_norm_scores_kde_smooth.png
- no_time_to_train/make_plots/heuristics_analysis/heatmap_center_bbox_norm_scores.png
- no_time_to_train/make_plots/heuristics_analysis/heatmap_center_segm_norm_scores_kde_smooth.png
- no_time_to_train/make_plots/heuristics_analysis/heatmap_center_segm_norm_scores.png
- no_time_to_train/make_plots/heuristics_analysis/per_class_area_vs_raw_scores.png
- no_time_to_train/make_plots/heuristics_analysis/all_classes_area_vs_norm_scores.png
- no_time_to_train/make_plots/heuristics_analysis/edge_distance_vs_norm_scores.png
- no_time_to_train/make_plots/heuristics_analysis/bars_area_category_norm_scores.png
- no_time_to_train/make_plots/heuristics_analysis/bars_centered_norm_scores.png
- no_time_to_train/make_plots/heuristics_analysis/bars_avoid_sides_norm_scores.png

[OUTPUT] Barplots. Effetto dell'area della maschera (sinistra) e della centralità (destra) sulle prestazioni

[OUTPUT] Heatmaps. Mappe 2D delle prestazioni in funzione della posizione del centro della maschera

[OUTPUT] Prestazioni per immagine di riferimento vs. area della maschera per tutte le nuove classi COCO

Degradazione dell'immagine di riferimento

Valutiamo il nostro metodo sotto immagini di riferimento progressivamente degradate applicando livelli crescenti di sfocatura gaussiana.

# Run different blur levels
bash scripts/blur_ablation/blur_ablation.sh
Plot grid of blur ablation results
python no_time_to_train/make_plots/plot_blur_results.py \
    --results-root ./work_dirs/blur_ablation \
    --class-id 0 \
    --max-cols 4 \
    --output-dir ./no_time_to_train/make_plots/blur_ablation \
    --outfile grid_blur_ablation_class_0.png

Somiglianza delle caratteristiche

Script per la visualizzazione della somiglianza tra le caratteristiche delle immagini di riferimento e quelle delle immagini target.

Genera la somiglianza di singole caratteristiche (caratteristiche di percorso) e la somiglianza basata su prototipi (caratteristiche aggregate).

python no_time_to_train/make_plots/feature_similarity.py \
  --classes orange \  
  --num-images 20 \
  --min-area 12 \
  --max-area 25000 \
  --min-instances 2 \
  --seed 123 \
  --max-per-class 12

Grafici T-SNE (separabilità delle feature DINOv2)

Il t-SNE delle feature DINOv2 mostra una chiara separazione per le classi dissimili ma una forte sovrapposizione per quelle simili, suggerendo che la confusione deriva dalla geometria delle feature del backbone piuttosto che dalla selezione dei prototipi.

python no_time_to_train/make_plots/tsne-coco.py --extract

# Example spoon vs fork
python no_time_to_train/make_plots/tsne-coco.py --classes cat dog

🛠️ Strumenti di supporto

Visualizzare la memoria

aggiungi l'immagine feature_comparison_small.png qui

python run_lightening.py test --config $CONFIG \
    --model.test_mode vis_memory \
    --ckpt_path $RESULTS_DIR/memory_postprocessed.ckpt \
    --model.init_args.dataset_cfgs.fill_memory.memory_pkl $RESULTS_DIR/$FILENAME \
    --model.init_args.dataset_cfgs.fill_memory.memory_length $SHOT \
    --model.init_args.dataset_cfgs.fill_memory.class_split $CLASS_SPLIT \
    --model.init_args.model_cfg.dataset_name $CLASS_SPLIT \
    --model.init_args.model_cfg.memory_bank_cfg.length $SHOT \
    --model.init_args.model_cfg.memory_bank_cfg.category_num $CATEGORY_NUM \
    --trainer.devices 1

Ridimensiona le immagini a 512x512 (rendi le immagini quadrate)

Per ridimensionare le immagini a 512x512 e salvarle in una nuova directory, esegui il seguente comando. Questo è per le figure dell'articolo.

python no_time_to_train/make_plots/paper_fig_square_imgs.py

Dimensione del modello e memoria

Per calcolare la dimensione del modello e la memoria, eseguire il seguente comando.

🌍 Dataset EO

Script di valutazione (dataset EO)

Gli script di valutazione si trovano nella directory scripts/EO. I dataset EO utilizzano lo script ./scripts/EO/EO_template.sh per eseguire la valutazione.

Ogni esecuzione di esperimento EO viene salvata nella directory ./EO_results. Nella cartella dell'esperimento memorizziamo:

• Il file summary.txt con la configurazione e il runtime dell'esperimento.
• Le visualizzazioni delle predizioni sul set di test (cartella results_analysis).
• Le visualizzazioni della memoria (cartella memory_vis).
• Il file pickle delle annotazioni few-shot.
• I checkpoint del modello (se non rimossi).

Figure e tabelle

python scripts/convert_datasets/summary_table_datasets.py

python scripts/paper_figures/table_EO_results.py ./EO_results_no_heuristics

python scripts/paper_figures/plot_EO_accuracy.py \
  --input-root ./EO_results \
  --output-root ./EO_results

python scripts/paper_figures/plot_EO_heuristic.py \
  --no-heuristics ./EO_results_no_heuristics \
  --heuristics ./EO_results

python scripts/paper_figures/plot_EO_runtime.py \
  --input-root ./EO_results \
  --output-root ./EO_results

python scripts/paper_figures/plot_EO_grid.py \
  --root ./EO_results_no_heuristics \
  --dataset ISAID \
  --shots 1

📚 Citation

If you use this work, please cite us:

@article{espinosa2025notimetotrain,
  title={No time to train! Training-Free Reference-Based Instance Segmentation},
  author={Miguel Espinosa and Chenhongyi Yang and Linus Ericsson and Steven McDonagh and Elliot J. Crowley},
  journal={arXiv preprint arXiv:2507.02798},
  year={2025},
  primaryclass={cs.CV}
}

--- Tranlated By Open Ai Tx | Last indexed: 2026-03-13 ---