🌐 Idioma

🚀 ¡Sin Tiempo para Entrenar!

Segmentación de Instancias Basada en Referencia Sin Entrenamiento

Estado del 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)

🚨 Actualización (22 de julio de 2025): ¡Se han añadido instrucciones para conjuntos de datos personalizados!

🔔 Actualización (16 de julio de 2025): ¡El código ha sido actualizado con instrucciones!

📋 Tabla de Contenidos

🎯 Puntos destacados
📜 Resumen
🧠 Arquitectura
🛠️ Instrucciones de instalación
1. Clonar el repositorio
2. Crear entorno conda
3. Instalar SAM2 y DinoV2
4. Descargar conjuntos de datos
5. Descargar puntos de control de SAM2 y DinoV2
📊 Código de inferencia: Reproducir resultados SOTA de 30-shot en Few-shot COCO
0. Crear conjunto de referencia
1. Llenar la memoria con referencias
2. Post-procesar el banco de memoria
3. Inferencia en imágenes objetivo
Resultados
🔍 Conjunto de datos personalizado
0. Preparar un conjunto de datos personalizado ⛵🐦
0.1 Si solo se dispone de anotaciones de bbox
0.2 Convertir anotaciones coco a archivo pickle
1. Llenar la memoria con referencias
2. Postprocesar el banco de memoria
📚 Cita

🎯 Destacados

💡 Sin entrenamiento: Sin fine-tuning, sin ingeniería de prompts—solo una imagen de referencia.
🖼️ Basado en referencias: Segmenta nuevos objetos usando solo unos pocos ejemplos.
🔥 Rendimiento SOTA: Supera los enfoques previos sin entrenamiento en COCO, PASCAL VOC y FSOD de dominio cruzado.

Enlaces:

📜 Resumen

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. Crear un entorno conda

Crearemos un entorno conda con los paquetes requeridos.

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

3. Instalar SAM2 y DinoV2

Instalaremos SAM2 y DinoV2 desde el código fuente.

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

4. Descargar conjuntos de datos

Por favor, descargue el conjunto de datos COCO y colóquelo en data/coco

5. Descargar puntos de control de SAM2 y DinoV2

Descargaremos exactamente los puntos de control de SAM2 utilizados en el artículo. (Sin embargo, tenga en cuenta que los puntos de control SAM2.1 ya están disponibles y podrían tener un mejor rendimiento.)

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

📊 Código de inferencia

⚠️ Descargo de responsabilidad: Este es código de investigación — ¡espere un poco de caos!

Reproducción de los resultados SOTA de 30 ejemplos en Few-shot COCO

Defina variables útiles y cree una carpeta para los resultados:

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. Crear conjunto de referencia

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

#### 1. Llenar la memoria con referencias

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. Posprocesar banco de memoria

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. Inferencia en imágenes objetivo

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 deseas ver los resultados de inferencia en línea (a medida que se calculan), añade el argumento:

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

Para ajustar el parámetro de umbral de puntuación score_thr, agregue el argumento (por ejemplo, para visualizar todas las instancias con una puntuación mayor que 0.4):

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

Las imágenes ahora se guardarán en results_analysis/few_shot_classes/. La imagen de la izquierda muestra la verdad de terreno, la imagen de la derecha muestra las instancias segmentadas encontradas por nuestro método sin entrenamiento.

Tenga en cuenta que en este ejemplo estamos usando la división few_shot_classes, por lo tanto, solo deberíamos esperar ver instancias segmentadas de las clases en esta división (no todas las clases en COCO).

#### Resultados

Después de procesar todas las imágenes en el conjunto de validación, deberías obtener:

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

🔍 Conjunto de datos personalizado

Proporcionamos las instrucciones para ejecutar nuestra canalización en un conjunto de datos personalizado. El formato de anotación es siempre en formato COCO.

TLDR; Para ver directamente cómo ejecutar la canalización completa en conjuntos de datos personalizados, consulta scripts/matching_cdfsod_pipeline.sh junto con los scripts de ejemplo de conjuntos de datos CD-FSOD (por ejemplo, scripts/dior_fish.sh)

0. Preparar un conjunto de datos personalizado ⛵🐦

Imaginemos que queremos detectar barcos⛵ y aves🐦 en un conjunto de datos personalizado. Para usar nuestro método necesitaremos:

Al menos 1 imagen anotada de referencia para cada clase (es decir, 1 imagen de referencia para barco y 1 imagen de referencia para ave)
Varias imágenes objetivo para encontrar instancias de nuestras clases deseadas.

Hemos preparado un script de ejemplo para crear un conjunto de datos personalizado con imágenes COCO, para un escenario de 1-shot.

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

Esto creará un conjunto de datos personalizado con la siguiente estructura de carpetas:

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)

Visualización de imágenes de referencia (1-shot):

0.1 Si solo se dispone de anotaciones bbox

También proporcionamos un script para generar máscaras de segmentación a nivel de instancia usando SAM2. Esto es útil si solo dispone de anotaciones de caja delimitadora para las imágenes de referencia.

# 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

Imágenes de referencia con máscaras de segmentación a nivel de instancia (generadas por SAM2 a partir de cajas delimitadoras gt, 1-shot):

La visualización de las máscaras de segmentación generadas se guarda en data/my_custom_dataset/annotations/custom_references_with_SAM_segm/references_visualisations/.

| Imagen de referencia 1-shot para PÁJARO 🐦 (segmentada automáticamente con SAM) | Imagen de referencia 1-shot para BARCO ⛵ (segmentada automáticamente con SAM) | |:---------------------------------:|:----------------------------------:| | bird_1_with_SAM_segm | boat_1_with_SAM_segm |

0.2 Convertir anotaciones coco a archivo 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. Llenar la memoria con referencias

Primero, defina variables útiles y cree una carpeta para los resultados. Para la correcta visualización de las etiquetas, los nombres de las clases deben ordenarse por el id de categoría tal como aparece en el archivo json. Por ejemplo, bird tiene el id de categoría 16, boat tiene el id de categoría 9. Por lo tanto, 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

Ejecute el paso 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. Banco de memoria de post-procesamiento

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. Inferencia en imágenes objetivo

Si ONLINE_VIS está configurado en True, los resultados de las predicciones se guardarán en results_analysis/my_custom_dataset/ y se mostrarán a medida que se calculan. NOTA: ejecutar con visualización en línea es mucho más lento.

Siéntase libre de cambiar el umbral de puntuación VIS_THR para ver más o menos instancias segmentadas.

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

Resultados

Las métricas de rendimiento (con los mismos parámetros exactos que los comandos anteriores) deberían ser:

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

Los resultados visuales se guardan en results_analysis/my_custom_dataset/. Tenga en cuenta que nuestro método funciona para falsos negativos, es decir, imágenes que no contienen ninguna instancia de las clases deseadas.

Haga clic en las imágenes para ampliarlas ⬇️

| Imagen objetivo con barcos ⛵ (izquierda GT, derecha predicciones) | Imagen objetivo con pájaros 🐦 (izquierda GT, derecha predicciones) | |:----------------------:|:----------------------:| | 000000459673 | 000000407180 |

| Imagen objetivo con barcos y pájaros ⛵🐦 (izquierda GT, derecha predicciones) | Imagen objetivo sin barcos ni pájaros 🚫 (izquierda GT, derecha predicciones) | |:---------------------------------:|:----------------------------------:| | 000000517410 | 000000460598 |

📚 Citación

Si utiliza este trabajo, por favor cítanos:

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