🌐 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 (22 juillet 2025): Les instructions pour les ensembles de données personnalisés ont été ajoutées !

🔔 Mise à jour (16 juillet 2025): Le code a été mis à jour avec les 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 ensembles 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 un ensemble de références
1. Remplir la mémoire avec les références
2. Post-traiter la banque de 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 de fine-tuning, pas d’ingénierie de prompt—juste une image de référence.
🖼️ Basé sur la référence : Segmenter de nouveaux objets avec seulement quelques exemples.
🔥 Performance SOTA : Surpasse les approches précédentes sans entraînement 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 à partir du 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

3. Inférence sur les images cibles

Si ONLINE_VIS est réglé sur True, les résultats de 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 la visualisation en ligne est beaucoup plus lente.

N'hésitez pas à modifier le seuil de score VIS_THR pour voir 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 des bateaux ⛵ (gauche GT, droite prédictions) | Image cible avec des oiseaux 🐦 (gauche GT, droite prédictions) | |:----------------------:|:----------------------:| | 000000459673 | 000000407180 |

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

📚 Citation

Si vous utilisez ce travail, veuillez nous citer :

@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: 2025-09-06 ---