🚀 Sem Tempo Para Treinar!

Segmentação de Instâncias Baseada em Referência Sem Treinamento

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

🚨 Atualização (5 de fevereiro de 2026): O manuscrito do artigo foi atualizado com extensos estudos de ablação, visualizações e experimentos adicionais.

🚨 Atualização (22 de julho de 2025): Instruções para conjuntos de dados personalizados foram adicionadas!

🔔 Atualização (16 de julho de 2025): Código atualizado com instruções!

📋 Índice

• 🎯 Destaques
• 📜 Resumo
• 🧠 Arquitetura
• 🛠️ Instruções de instalação
• 1. Clonar o repositório
• 2. Criar ambiente conda
• 3. Instalar SAM2 e DINOv2
• 4. Baixar conjuntos de dados
• 5. Baixar pontos de verificação do SAM2 e DINOv2
• 📊 Código de inferência: Reproduza resultados SOTA 30-shot em Few-shot COCO
• 0. Criar conjunto de referência
• 1. Preencher memória com referências
• 2. Pós-processar o banco de memória
• 3. Inferência em imagens alvo
• Resultados
• 🔍 Conjunto de dados personalizado
• 0. Preparar um conjunto de dados personalizado ⛵🐦
• 0.1 Se apenas anotações de bbox estiverem disponíveis
• 0.2 Converter anotações COCO para arquivo pickle
• 1. Preencher a memória com referências
• 2. Pós-processar o banco de memória
• 📚 Citação

🎯 Destaques

• 💡 Sem Treinamento: Sem fine-tuning, sem prompt engineering—apenas uma imagem de referência.
• 🖼️ Baseado em Referência: Segmente novos objetos usando apenas alguns exemplos.
• 🔥 Desempenho SOTA: Supera abordagens anteriores sem treinamento no COCO, PASCAL VOC e Cross-Domain FSOD.

• 🧾 Artigo no arXiv
• 🌐 Site do Projeto
• 📈 Papers with Code

📜 Resumo

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. Criar ambiente conda

Vamos criar um ambiente conda com os pacotes necessários.

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

3. Instale SAM2 e DINOv2

Vamos instalar SAM2 e DINOv2 a partir do código-fonte.

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

4. Baixe os conjuntos de dados

Por favor, baixe o conjunto de dados COCO e coloque-o em data/coco

5. Baixe os checkpoints do SAM2 e DINOv2

Vamos baixar os checkpoints exatos do SAM2 usados no artigo. (Observe, no entanto, que os checkpoints do SAM2.1 já estão disponíveis e podem apresentar melhor desempenho.)

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 inferência

⚠️ Aviso: Este é um código de pesquisa — espere um pouco de caos!

Reproduzindo os resultados SOTA de 30 exemplos no Few-shot COCO

Defina variáveis úteis e crie uma pasta para os 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

Observe que neste exemplo estamos usando a divisão few_shot_classes, portanto, devemos esperar ver apenas instâncias segmentadas das classes presentes nesta divisão (não todas as classes do COCO).

#### Resultados

Após processar todas as imagens no conjunto de validação, você deverá obter:

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

Fornecemos as instruções para executar nosso pipeline em um conjunto de dados personalizado. O formato de anotação é sempre no formato COCO.

Resumindo; Para ver diretamente como executar o pipeline completo em conjuntos de dados personalizados, veja scripts/matching_cdfsod_pipeline.sh junto com scripts de exemplo dos conjuntos de dados CD-FSOD (por exemplo, scripts/dior_fish.sh)

0. Prepare um conjunto de dados personalizado ⛵🐦

Vamos imaginar que queremos detectar barcos⛵ e pássaros🐦 em um conjunto de dados personalizado. Para usar nosso método, precisaremos de:

• Pelo menos 1 imagem de referência anotada para cada classe (ou seja, 1 imagem de referência para barco e 1 imagem de referência para pássaro)
• Múltiplas imagens-alvo para encontrar instâncias das classes desejadas.

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)

| Imagem de Referência 1-shot para PÁSSARO 🐦 | Imagem de Referência 1-shot para BARCO ⛵ | |:-------------------------------------------:|:-----------------------------------------:| | | |

0.1 Se apenas anotações de bbox estiverem disponíveis

Também fornecemos um script para gerar máscaras de segmentação em nível de instância usando o SAM2. Isso é útil caso você só tenha anotações de caixa delimitadora disponíveis para as imagens de referência.

# 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

A visualização das máscaras de segmentação geradas está salva em data/my_custom_dataset/annotations/custom_references_with_SAM_segm/references_visualisations/.

| Imagem de Referência 1-shot para PÁSSARO 🐦 (segmentada automaticamente com SAM) | Imagem de Referência 1-shot para BARCO ⛵ (segmentada automaticamente com SAM) | |:---------------------------------:|:----------------------------------:| | | |

0.2 Converter anotações coco para arquivo 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. Preencher a memória com referências

Primeiro, defina variáveis úteis e crie uma pasta para os resultados. Para a correta visualização dos rótulos, os nomes das classes devem ser ordenados pelo id da categoria conforme aparece no arquivo json. Por exemplo, bird tem o id de categoria 16, boat tem o id de categoria 9. Assim, 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. Pós-processar banco de memória

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 memória pós-processado

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. Inferência em imagens alvo

Se ONLINE_VIS estiver definido como True, os resultados das previsões serão salvos em results_analysis/my_custom_dataset/ e exibidos à medida que forem computados. NOTE que rodar com visualização online é muito mais lento.

Sinta-se à vontade para alterar o limiar de pontuação VIS_THR para ver mais ou menos instâncias 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

As métricas de desempenho (com exatamente os mesmos parâmetros dos comandos acima) devem 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

Os resultados visuais são salvos em results_analysis/my_custom_dataset/. Observe que nosso método funciona para falsos negativos, ou seja, imagens que não contêm nenhuma instância das classes desejadas.

Clique nas imagens para ampliar ⬇️

| Imagem alvo com barcos ⛵ (GT à esquerda, previsões à direita) | Imagem alvo com pássaros 🐦 (GT à esquerda, previsões à direita) | |:----------------------:|:----------------------:| | | |

| Imagem alvo com barcos e pássaros ⛵🐦 (GT à esquerda, previsões à direita) | Imagem alvo sem barcos ou pássaros 🚫 (GT à esquerda, previsões à direita) | |:---------------------------------:|:----------------------------------:| | | |

🔬 Ablações

Ablação do backbone

Para avaliar a transferibilidade do nosso método entre modelos foundation, substituímos tanto o codificador semântico (DINOv2) quanto o segmentador baseado em SAM por diversas alternativas.

Ablação do 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

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

Avaliação VLM no conjunto de dados COCO few-shot

Nós avaliamos o QWEN VLM no conjunto de dados COCO few-shot.

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

Heurísticas de imagem de referência

Para entender por que diferentes imagens de referência levam à variação de desempenho, analisamos as propriedades estatísticas das anotações das classes novas do COCO.

#### ANÁLISE

Estudamos três características das anotações: (1) área da máscara (tamanho do objeto), (2) localização do centro da máscara e (3) distância até as bordas da imagem.

# 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

[SAÍDA] Distribuição da área da máscara

[SAÍDA] Densidade do centro da Bbox

[SAÍDA] Histogramas de distância das bordas da Bbox

#### SELEÇÃO

Selecionamos 100 imagens de referência diversas por-chamada, cobrindo explicitamente uma variedade de tamanhos de máscara, centros e distâncias das bordas. Cada referência é avaliada em um subconjunto fixo e reduzido de validação.

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

Analisamos como as pontuações de detecção se correlacionam com as características da imagem de referência (tamanho da máscara, posição central, distância da borda).

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

[SAÍDA] Gráficos de barras. Efeito da área da máscara (esquerda) e centralização (direita) no desempenho

[SAÍDA] Mapas de calor. Mapas de pontuação 2D do desempenho em função da localização do centro da máscara

[SAÍDA] Desempenho da imagem de referência vs. área da máscara para todas as classes novas do COCO

Degradação da imagem de referência

Avaliamos nosso método sob imagens de referência progressivamente degradadas, aplicando níveis crescentes de desfoque 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

Similaridade de características

Script para visualizar a similaridade de características entre imagens de referência e imagens-alvo.

Ele gera similaridade de características únicas (características de caminho) e similaridade baseada em protótipos (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áficos T-SNE (separabilidade de características DINOv2)

O t-SNE das características do DINOv2 mostra uma separação clara para classes diferentes, mas grande sobreposição para classes semelhantes, sugerindo que a confusão decorre da geometria das características do backbone, e não da seleção de protótipos.

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

🛠️ Auxiliares

Visualizar memória

adicione a imagem feature_comparison_small.png aqui

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 imagens para 512x512 (tornar as imagens quadradas)

Para redimensionar as imagens para 512x512 e salvá-las em um novo diretório, execute o seguinte comando. Isso é para as figuras do artigo.

python no_time_to_train/make_plots/paper_fig_square_imgs.py

Tamanho do modelo e memória

Para calcular o tamanho do modelo e a memória, execute o seguinte comando.

🌍 Conjuntos de dados EO

Scripts de avaliação (conjuntos de dados EO)

Os scripts de avaliação podem ser encontrados no diretório scripts/EO. Os conjuntos de dados EO usam o script ./scripts/EO/EO_template.sh para rodar a avaliação.

Cada execução de experimento EO é salva no diretório ./EO_results. Na pasta do experimento armazenamos:

• O arquivo summary.txt com a configuração e tempo de execução do experimento.
• As visualizações das previsões no conjunto de teste (pasta results_analysis).
• As visualizações de memória (pasta memory_vis).
• O arquivo pickle das anotações few-shot.
• Os checkpoints do modelo (se não forem removidos).

Figuras e tabelas

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