🌐 Langue

🚀 Pas le temps de s'entraîner !

Segmentation d'instance basée sur la référence, sans entraînement

État de l'art (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)

🚨 Mise à jour (5 février 2026) : Le manuscrit de l'article a été mis à jour avec de nombreuses études d'ablation, des visualisations et des expériences supplémentaires.

🚨 Mise à jour (22 juillet 2025) : Des instructions pour les jeux de données personnalisés ont été ajoutées !

🔔 Mise à jour (16 juillet 2025) : Le code a été mis à jour avec des instructions !

📋 Table des matières

🎯 Points forts
📜 Résumé
🧠 Architecture
🛠️ Instructions d'installation
1. Cloner le dépôt
2. Créer l'environnement conda
3. Installer SAM2 et DINOv2
4. Télécharger les jeux de données
5. Télécharger les checkpoints SAM2 et DINOv2
📊 Code d'inférence : Reproduire les résultats SOTA 30-shot sur Few-shot COCO
0. Créer l'ensemble de référence
1. Remplir la mémoire avec les références
2. Post-traitement de la banque mémoire
3. Inférence sur les images cibles

Résultats
🔍 Jeu de données personnalisé
0. Préparer un jeu de données personnalisé ⛵🐦
0.1 Si seules des annotations bbox sont disponibles
0.2 Convertir les annotations coco en fichier pickle
1. Remplir la mémoire avec des références
2. Post-traiter la banque de mémoire
📚 Citation

🎯 Points forts

💡 Sans entraînement : Pas d’ajustement, pas d’ingénierie de prompt—juste une image de référence.
🖼️ Basé sur la référence : Segmentez de nouveaux objets avec seulement quelques exemples.
🔥 Performances SOTA : Surpasse les approches sans entraînement précédentes sur COCO, PASCAL VOC et Cross-Domain FSOD.

Liens :

📜 Résumé

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).

cdfsod-results-final-comic-sans-min

🧠 Architecture

training-free-architecture-comic-sans-min

🛠️ Installation instructions

1. Clone the repository

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

2. Créer un environnement conda

Nous allons créer un environnement conda avec les paquets requis.

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

3. Installer SAM2 et DINOv2

Nous allons installer SAM2 et DINOv2 depuis le code source.

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

4. Télécharger les jeux de données

Veuillez télécharger le jeu de données COCO et le placer dans data/coco

5. Télécharger les points de contrôle SAM2 et DINOv2

Nous allons télécharger exactement les points de contrôle SAM2 utilisés dans l’article. (Notez cependant que les points de contrôle SAM2.1 sont déjà disponibles et pourraient offrir de meilleures performances.)

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 ../..

📊 Code d'inférence

⚠️ Avertissement : Ceci est un code de recherche — attendez-vous à un peu de chaos !

Reproduire les résultats SOTA à 30 essais sur Few-shot COCO

Définissez des variables utiles et créez un dossier pour les résultats :

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=4mkdir -p $RESULTS_DIR
FILENAME=few_shot_${SHOTS}shot_seed${SEED}.pkl

#### 0. Créer un ensemble de référence

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

#### 1. Remplir la mémoire avec des références

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

#### 2. Post-traitement de la banque de mémoire

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

#### 3. Inférence sur les images cibles

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

Si vous souhaitez voir les résultats d'inférence en ligne (au fur et à mesure qu'ils sont calculés), ajoutez l'argument :

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

Pour ajuster le paramètre de seuil de score score_thr, ajoutez l'argument (par exemple, pour visualiser toutes les instances avec un score supérieur à 0.4) :

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

Les images seront maintenant enregistrées dans results_analysis/few_shot_classes/. L’image de gauche montre la vérité terrain, l’image de droite montre les instances segmentées trouvées par notre méthode sans apprentissage.

Notez que dans cet exemple nous utilisons la division few_shot_classes, donc, nous devons seulement nous attendre à voir des instances segmentées des classes de cette division (et non toutes les classes de COCO).

#### Résultats

Après avoir traité toutes les images de l’ensemble de validation, vous devriez obtenir :

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

🔍 Jeu de données personnalisé

Nous fournissons les instructions pour exécuter notre pipeline sur un jeu de données personnalisé. Les formats d'annotation sont toujours au format COCO.

TLDR ; Pour voir directement comment exécuter le pipeline complet sur des jeux de données personnalisés, consultez scripts/matching_cdfsod_pipeline.sh ainsi que des exemples de scripts pour les jeux de données CD-FSOD (par exemple scripts/dior_fish.sh)

0. Préparer un jeu de données personnalisé ⛵🐦

Imaginons que nous voulons détecter des bateaux⛵ et des oiseaux🐦 dans un jeu de données personnalisé. Pour utiliser notre méthode, il nous faudra :

Au moins 1 image de référence annotée pour chaque classe (c'est-à-dire 1 image de référence pour bateau et 1 image de référence pour oiseau)
Plusieurs images cibles pour trouver des instances des classes souhaitées.

Nous avons préparé un script d'exemple pour créer un jeu de données personnalisé avec des images coco, pour un scénario 1-shot.

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

Cela créera un jeu de données personnalisé avec la structure de dossiers suivante :

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)

Visualisation des images de référence (1-shot) :

0.1 Si seules des annotations bbox sont disponibles

Nous fournissons également un script pour générer des masques de segmentation au niveau instance en utilisant SAM2. Ceci est utile si vous ne disposez que d’annotations de boîtes englobantes pour les images de référence.

# 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

Images de référence avec masques de segmentation au niveau des instances (générés par SAM2 à partir des boîtes englobantes gt, 1-shot) :

La visualisation des masques de segmentation générés est enregistrée dans data/my_custom_dataset/annotations/custom_references_with_SAM_segm/references_visualisations/.

| Image de référence 1-shot pour OISEAU 🐦 (segmentée automatiquement avec SAM) | Image de référence 1-shot pour BATEAU ⛵ (segmentée automatiquement avec SAM) | |:---------------------------------:|:----------------------------------:| | bird_1_with_SAM_segm | boat_1_with_SAM_segm |

0.2 Convertir les annotations coco en fichier 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. Remplir la mémoire avec des références

Tout d'abord, définissez les variables utiles et créez un dossier pour les résultats. Pour une visualisation correcte des étiquettes, les noms de classes doivent être ordonnés par identifiant de catégorie comme dans le fichier json. Par exemple, bird a l'identifiant de catégorie 16, boat a l'identifiant de catégorie 9. Ainsi, 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

Exécutez l’étape 1 :

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. Banque de mémoire post-traitement

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 Visualiser la banque de mémoire post-traitée

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

Les visualisations PCA et K-means pour les images de la mémoire tampon sont stockées dans results_analysis/memory_vis/my_custom_dataset.

3. Inférence sur les images cibles

Si ONLINE_VIS est défini sur True, les résultats de la prédiction seront sauvegardés dans results_analysis/my_custom_dataset/ et affichés au fur et à mesure de leur calcul. NOTEZ que l’exécution avec visualisation en ligne est beaucoup plus lente.

N'hésitez pas à modifier le seuil de score VIS_THR pour afficher plus ou moins d’instances segmentées.

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

Résultats

Les métriques de performance (avec exactement les mêmes paramètres que les commandes ci-dessus) devraient être :

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

Les résultats visuels sont enregistrés dans results_analysis/my_custom_dataset/. Notez que notre méthode fonctionne pour les faux négatifs, c’est-à-dire les images qui ne contiennent aucune instance des classes souhaitées.

Cliquez sur les images pour agrandir ⬇️

| Image cible avec bateaux ⛵ (gauche GT, droite prédictions) | Image cible avec oiseaux 🐦 (gauche GT, droite prédictions) | |:----------------------:|:----------------------:| | 000000459673 | 000000407180 |

| Image cible avec bateaux et oiseaux ⛵🐦 (gauche GT, droite prédictions) | Image cible sans bateaux ni oiseaux 🚫 (gauche GT, droite prédictions) | |:---------------------------------:|:----------------------------------:| | 000000517410 | 000000460598 |

🔬 Ablations

Ablation du backbone

Pour évaluer la transférabilité de notre méthode à travers différents modèles fondamentaux, nous remplaçons à la fois l’encodeur sémantique (DINOv2) et le segmentateur basé sur SAM par plusieurs alternatives.

Ablation de l’encodeur sémantique :

# 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

Ablation du segmentateur :

# 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

Évaluation de VLM sur le jeu de données COCO en few-shot

Nous évaluons QWEN VLM sur le jeu de données COCO en few-shot.

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

Heuristiques sur les images de référence

Pour comprendre pourquoi différentes images de référence entraînent des variations de performance, nous analysons les propriétés statistiques des annotations des nouvelles classes COCO.

#### ANALYSE

Nous étudions trois caractéristiques d'annotation : (1) la surface du masque (taille de l'objet), (2) la position du centre du masque, et (3) la distance aux bords de l'image.

Instructions :

# 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

[SORTIE] Distribution de la surface des masques

[SORTIE] Densité du centre des Bbox

[SORTIE] Histogrammes des distances aux bords des Bbox

#### SÉLECTION

Nous échantillonnons 100 images de référence diverses par classe, couvrant explicitement une gamme de tailles de masques, de centres et de distances aux bords. Chaque référence est évaluée sur un sous-ensemble de validation réduit et fixe.

Instructions :

Script de configuration : scripts/1shot_ref_ablation/setup.sh :

Créer un fichier json par classe
Analyser une classe spécifique
Créer un ensemble de références avec différentes heuristiques

bash scripts/1shot_ref_ablation/setup.sh

Exécutez les scripts : scripts/1shot_ref_ablation/gpu*.sh :

Exécutez le pipeline pour chaque ensemble de références

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

#### RÉSULTATS

Nous analysons comment les scores de détection sont corrélés avec les caractéristiques de l'image de référence (taille du masque, position du centre, distance au bord).

Instructions :

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] Diagrammes en barres. Effet de la surface du masque (gauche) et du centrage (droite) sur la performance

[OUTPUT] Cartes de chaleur. Cartes de score 2D de la performance en fonction de la localisation du centre du masque

[OUTPUT] Performance image de référence vs. surface du masque pour toutes les classes inédites COCO

Dégradation de l’image de référence

Nous évaluons notre méthode sur des images de référence progressivement dégradées en appliquant des niveaux croissants de flou gaussien. ablation-blur

Instructions :

# 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

Similarité des caractéristiques

Script pour visualiser la similarité des caractéristiques entre les images de référence et les images cibles.

Il génère la similarité à une seule caractéristique (caractéristiques de chemin), et la similarité basée sur des prototypes (caractéristiques agrégées). feature_similarity_small

Instructions :

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

Graphiques T-SNE (séparabilité des caractéristiques DINOv2)

Le t-SNE des caractéristiques DINOv2 montre une séparation nette pour les classes dissemblables, mais un chevauchement important pour les classes similaires, suggérant que la confusion provient de la géométrie des caractéristiques du backbone plutôt que de la sélection des prototypes. tsne

Instructions :

Extraire les caractéristiques

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

Tracer des graphiques T-SNE

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

🛠️ Outils

Visualiser la mémoire

ajoutez l'image feature_comparison_small.png ici

Instructions

Pour visualiser la banque de mémoire (visualisations PCA et K-means) pour une expérience donnée, ajustez la commande suivante.

Définissez DO_NOT_CROP sur True/False (dans no_time_to_train/models/Sam2MatchingBaseline_noAMG.py) pour visualiser l'image de référence avec/sans le masque recadré.

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

Redimensionner les images à 512x512 (mettre les images au format carré)

Pour redimensionner les images à 512x512 et les enregistrer dans un nouveau répertoire, exécutez la commande suivante. Ceci est pour les figures de l'article.

Instructions :

python no_time_to_train/make_plots/paper_fig_square_imgs.py

Taille du modèle et mémoire

Pour calculer la taille du modèle et la mémoire, exécutez la commande suivante.

Instructions :

Voir no_time_to_train/models/Sam2MatchingBaseline_noAMG_model_and_memory.py pour le calcul de la taille du modèle et de la mémoire.

(Le plus simple : remplacer temporairement par Sam2MatchingBaseline_noAMG.py, puis renommer à nouveau.)

🌍 Jeux de données EO

Scripts d'évaluation (jeux de données EO)

Les scripts d'évaluation se trouvent dans le répertoire scripts/EO. Les jeux de données EO utilisent le script ./scripts/EO/EO_template.sh pour exécuter l'évaluation.

Chaque exécution d'expérience EO est enregistrée dans le répertoire ./EO_results. Dans le dossier d'expérience, nous stockons :

Le fichier summary.txt avec la configuration et le temps d'exécution de l'expérience.
Les visualisations de prédictions sur le jeu de test (dossier results_analysis).
Les visualisations de mémoire (dossier memory_vis).
Le fichier pickle d'annotation few-shot.
Les checkpoints du modèle (s'ils ne sont pas nettoyés).

Figures et tableaux

Scripts supplémentaires pour générer des figures et des tableaux.

Résumé tableau latex des jeux de données EO :

python scripts/convert_datasets/summary_table_datasets.py

Générer un tableau LaTeX des ensembles de données EO :

python scripts/paper_figures/table_EO_results.py ./EO_results_no_heuristics

Graphique d'exactitude des ensembles de données EO :

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

Résumé de l'effet des heuristiques sur les ensembles de données EO :

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

Graphique du temps d'exécution des ensembles de données EO :

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

Générer des visualisations de grille EO pour la figure de l'article :

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 ---