🚀 ¡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 (5 de febrero de 2026): El manuscrito del artículo ha sido actualizado con extensos estudios de ablación, visualizaciones y experimentos adicionales.

🚨 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

• 🎯 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 checkpoints de SAM2 y DINOv2
• 📊 Código de inferencia: Reproducir resultados SOTA 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 bbox
• 0.2 Convertir anotaciones coco a archivo pickle
• 1. Llenar la memoria con referencias
• 2. Postprocesar banco de memoria
• 📚 Citación

🎯 Aspectos destacados

• 💡 Sin entrenamiento: Sin ajuste fino, sin ingeniería de prompts—solo una imagen de referencia.
• 🖼️ Basado en referencia: Segmenta nuevos objetos usando solo unos pocos ejemplos.
• 🔥 Rendimiento SOTA: Supera a enfoques previos sin entrenamiento en COCO, PASCAL VOC y Cross-Domain FSOD.

• 🧾 Artículo en arXiv
• 🌐 Sitio web del proyecto
• 📈 Papers with Code

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

🧠 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. 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 los puntos de control de SAM2 y DINOv2

Descargaremos los mismos puntos de control de SAM2 utilizados en el artículo. (Tenga en cuenta, sin embargo, que los puntos de control SAM2.1 ya están disponibles y pueden funcionar mejor.)

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

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.368
SEGM 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.

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)

| Imagen de referencia 1-shot para PÁJARO 🐦 | Imagen de referencia 1-shot para BARCO ⛵ | |:-----------------------------------------:|:----------------------------------------:| | | |

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

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

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

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

#### 2.1 Visualizar banco de memoria posprocesado

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

Si ONLINE_VIS está configurado como True, los resultados de la predicción se guardarán en results_analysis/my_custom_dataset/ y se mostrarán a medida que se calculan. TENGA EN CUENTA que 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.478
SEGM 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.

Haz clic en las imágenes para ampliar ⬇️

| Imagen objetivo con barcos ⛵ (izquierda GT, derecha predicciones) | Imagen objetivo con aves 🐦 (izquierda GT, derecha predicciones) | |:----------------------:|:----------------------:| | | |

| Imagen objetivo con barcos y aves ⛵🐦 (izquierda GT, derecha predicciones) | Imagen objetivo sin barcos ni aves 🚫 (izquierda GT, derecha predicciones) | |:---------------------------------:|:----------------------------------:| | | |

🔬 Ablaciones

Ablación del backbone

Para evaluar la transferibilidad de nuestro método entre modelos fundacionales, reemplazamos tanto el codificador semántico (DINOv2) como el segmentador basado en SAM con varias alternativas.

Ablación del codificador semántico:

# 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

Ablación del segmentador:

# 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

Evaluación de VLM en el conjunto de datos COCO few-shot

Evaluamos QWEN VLM en el conjunto de datos COCO few-shot.

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

Heurísticas de imágenes de referencia

Para entender por qué diferentes imágenes de referencia conducen a variaciones en el rendimiento, analizamos las propiedades estadísticas de las anotaciones de clases nuevas de COCO.

#### ANÁLISIS

Estudiamos tres características de anotación: (1) área de la máscara (tamaño del objeto), (2) ubicación del centro de la máscara, y (3) distancia a los bordes de la imagen.

# 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] Distribución del área de la máscara

[OUTPUT] Densidad del centro del Bbox

[OUTPUT] Histogramas de distancia al borde del Bbox

#### SELECCIÓN

Tomamos muestras de 100 imágenes de referencia diversas por clase, cubriendo explícitamente una gama de tamaños de máscara, centros y distancias a los bordes. Cada referencia se evalúa en un subconjunto fijo y reducido de validación.

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

#### RESULTADOS

Analizamos cómo los puntajes de detección se correlacionan con las características de la imagen de referencia (tamaño de la máscara, posición central, distancia al borde).

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] Diagramas de barras. Efecto del área de la máscara (izquierda) y la centralidad (derecha) en el rendimiento

[OUTPUT] Mapas de calor. Mapas de puntuación 2D del rendimiento en función de la ubicación del centro de la máscara

[OUTPUT] Rendimiento de imagen de referencia vs. área de máscara para todas las clases nuevas de COCO

Degradación de la imagen de referencia

Evaluamos nuestro método bajo imágenes de referencia progresivamente degradadas aplicando niveles crecientes de desenfoque gaussiano.

# 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

Similitud de características

Script para visualizar la similitud de características entre imágenes de referencia e imágenes objetivo.

Genera similitud de característica única (características de ruta) y similitud basada en prototipos (características agregadas).

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

Gráficas T-SNE (Separabilidad de características DINOv2)

El t-SNE de las características de DINOv2 muestra una clara separación para clases disímiles pero una gran superposición para clases similares, lo que sugiere que la confusión proviene de la geometría de las características del backbone más que de la selección de prototipos.

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

🛠️ Ayudantes

Visualizar memoria

agrega la imagen feature_comparison_small.png aquí

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

Redimensionar imágenes a 512x512 (hacer las imágenes cuadradas)

Para redimensionar las imágenes a 512x512 y guardarlas en un nuevo directorio, ejecuta el siguiente comando. Esto es para las figuras del artículo.

python no_time_to_train/make_plots/paper_fig_square_imgs.py

Tamaño del modelo y memoria

Para calcular el tamaño del modelo y la memoria, ejecuta el siguiente comando.

🌍 Conjuntos de datos EO

Scripts de evaluación (conjuntos de datos EO)

Los scripts de evaluación se encuentran en el directorio scripts/EO. Los conjuntos de datos EO utilizan el script ./scripts/EO/EO_template.sh para ejecutar la evaluación.

Cada ejecución de experimento EO se guarda en el directorio ./EO_results. En la carpeta del transportamos:

• El archivo summary.txt con la configuración y el tiempo de ejecución del experimento.
• Las visualizaciones de predicción en el conjunto de prueba (carpeta results_analysis).
• Las visualizaciones de memoria (carpeta memory_vis).
• El archivo pickle de anotaciones few-shot.
• Los checkpoints del modelo (si no se han eliminado).

Figuras y tablas

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