🌐 Idioma

🚀 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 (22 de julho de 2025): Instruções para conjuntos de dados personalizados foram adicionadas!

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

📋 Índice

🎯 Destaques
📜 Resumo
🧠 Arquitetura
🛠️ Instruções de instalação
1. Clone o repositório
2. Crie o ambiente conda
3. Instale SAM2 e DinoV2
4. Baixe os conjuntos de dados
5. Baixe os checkpoints do SAM2 e DinoV2
📊 Código de inferência: Reproduza os resultados SOTA de 30-shot em Few-shot COCO
0. Crie o conjunto de referências
1. Preencha a memória com referências
2. Pós-processamento do banco de memória
3. Inferência em imagens-alvo
Resultados

🔍 Conjunto de dados personalizado
0. Prepare 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 memória com referências
2. Pós-processar banco de memória
📚 Citação

🎯 Destaques

💡 Sem Treinamento: Sem ajuste fino, sem engenharia de prompts—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 FSOD Cross-Domain.

Links:

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

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. 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 o SAM2 e o DinoV2 a partir do código-fonte.

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

4. Baixar conjuntos de dados

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

5. Baixar checkpoints do SAM2 e DinoV2

Vamos baixar os mesmos checkpoints do SAM2 utilizados 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=4mkdir -p $RESULTS_DIR
FILENAME=few_shot_${SHOTS}shot_seed${SEED}.pkl

#### 0. Criar conjunto de referência

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

#### 1. Preencha a memória com referências

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. Pós-processar banco de memória

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

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

Se você quiser ver os resultados da inferência online (à medida que são computados), adicione o argumento:

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

Para ajustar o parâmetro de limiar de pontuação score_thr, adicione o argumento (por exemplo, visualizando todas as instâncias com pontuação superior a 0.4):

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

As imagens agora serão salvas em results_analysis/few_shot_classes/. A imagem à esquerda mostra o valor real (ground truth), enquanto a imagem à direita mostra as instâncias segmentadas encontradas pelo nosso método sem treinamento.

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

Preparamos um script de exemplo para criar um conjunto de dados personalizado com imagens COCO, para um cenário de 1-shot.

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

Isso criará um conjunto de dados personalizado com a seguinte estrutura de pastas:

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)

Visualização de imagens de referência (1-shot):

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

Imagens de referência com máscaras de segmentação em nível de instância (geradas pelo SAM2 a partir de caixas delimitadoras gt, 1-shot):

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

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

Execute a etapa 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. 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

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. OBSERVE que executar 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.478SEGM 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/. Note 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 ⛵ (esquerda GT, direita previsões) | Imagem alvo com pássaros 🐦 (esquerda GT, direita previsões) | |:----------------------:|:----------------------:| | 000000459673 | 000000407180 |

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

📚 Citação

Se você usar este trabalho, por favor nos cite:

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