🚀 Nie ma czasu na trening!

Segmentacja obiektów na podstawie referencji bez treningu

Stan techniki (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)

🚨 Aktualizacja (5 lutego 2026): Rękopis artykułu został zaktualizowany o obszerne badania ablacyjne, wizualizacje i dodatkowe eksperymenty.

🚨 Aktualizacja (22 lipca 2025): Dodano instrukcje dla niestandardowych zbiorów danych!

🔔 Aktualizacja (16 lipca 2025): Kod został zaktualizowany wraz z instrukcjami!

📋 Spis treści

• 🎯 Najważniejsze informacje
• 📜 Streszczenie
• 🧠 Architektura
• 🛠️ Instrukcje instalacji
• 1. Sklonuj repozytorium
• 2. Utwórz środowisko conda
• 3. Zainstaluj SAM2 i DINOv2
• 4. Pobierz zbiory danych
• 5. Pobierz checkpointy SAM2 i DINOv2
• 📊 Kod wnioskowania: Reprodukuj wyniki SOTA 30-shot w Few-shot COCO
• 0. Utwórz zbiór referencyjny
• 1. Wypełnij pamięć referencjami
• 2. Przetwarzanie banku pamięci
• 3. Wnioskowanie na obrazach docelowych
• Wyniki
• 🔍 Niestandardowy zbiór danych
• 0. Przygotuj niestandardowy zbiór danych ⛵🐦
• 0.1 Jeśli dostępne są tylko adnotacje bbox
• 0.2 Konwertuj adnotacje coco do pliku pickle
• 1. Wypełnij pamięć referencjami
• 2. Przetwórz bank pamięci
• 📚 Cytowanie

🎯 Najważniejsze cechy

• 💡 Bez treningu: Bez fine-tuningu, bez inżynierii promptów—tylko obraz referencyjny.
• 🖼️ Na podstawie referencji: Segmentuj nowe obiekty używając zaledwie kilku przykładów.
• 🔥 SOTA Wydajność: Przewyższa wcześniejsze podejścia bez treningu na COCO, PASCAL VOC i Cross-Domain FSOD.

• 🧾 Artykuł na arXiv
• 🌐 Strona projektu
• 📈 Papers with Code

📜 Streszczenie

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. Utwórz środowisko conda

Utworzymy środowisko conda z wymaganymi pakietami.

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

3. Zainstaluj SAM2 i DINOv2

Zainstalujemy SAM2 i DINOv2 ze źródła.

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

4. Pobierz zbiory danych

Proszę pobrać zbiór danych COCO i umieścić go w data/coco

5. Pobierz punkty kontrolne SAM2 i DINOv2

Pobierzemy dokładnie te punkty kontrolne SAM2, które były użyte w artykule. (Należy jednak zauważyć, że punkty kontrolne SAM2.1 są już dostępne i mogą działać lepiej.)

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

📊 Kod inferencji

⚠️ Zastrzeżenie: To jest kod badawczy — spodziewaj się trochę chaosu!

Reprodukowanie wyników SOTA z 30 próbkami w Few-shot COCO

Zdefiniuj przydatne zmienne i utwórz folder na wyniki:

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

Zwróć uwagę, że w tym przykładzie używamy podziału few_shot_classes, dlatego powinniśmy spodziewać się segmentacji tylko tych klas, które znajdują się w tym podziale (nie wszystkich klas w COCO).

#### Wyniki

Po przetworzeniu wszystkich obrazów w zestawie walidacyjnym powinieneś otrzymać:

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

🔍 Własny zbiór danych

Podajemy instrukcje dotyczące uruchomienia naszego pipeline'u na własnym zbiorze danych. Format adnotacji zawsze musi być w formacie COCO.

TLDR; Aby bezpośrednio zobaczyć, jak uruchomić pełny pipeline na własnych zbiorach danych, zobacz scripts/matching_cdfsod_pipeline.sh wraz z przykładowymi skryptami dla zbiorów CD-FSOD (np. scripts/dior_fish.sh)

0. Przygotuj własny zbiór danych ⛵🐦

Załóżmy, że chcemy wykrywać łodzie⛵ oraz ptaki🐦 w niestandardowym zbiorze danych. Aby użyć naszej metody, będziemy potrzebować:

• Przynajmniej 1 zaadnotowanego obrazu referencyjnego dla każdej klasy (tj. 1 obraz referencyjny dla łodzi i 1 obraz referencyjny dla ptaka)
• Wiele obrazów docelowych do wyszukiwania instancji naszych pożądanych klas.

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)

| 1-strzałowy obraz referencyjny PTAK 🐦 | 1-strzałowy obraz referencyjny ŁÓDŹ ⛵ | |:--------------------------------------:|:--------------------------------------:| | | |

0.1 Jeśli dostępne są tylko adnotacje bbox

Zapewniamy także skrypt do generowania masek segmentacji na poziomie instancji przy użyciu SAM2. Jest to przydatne, jeśli dla obrazów referencyjnych dostępne są tylko adnotacje w postaci ramek ograniczających.

# 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

Wizualizacje wygenerowanych masek segmentacji są zapisane w data/my_custom_dataset/annotations/custom_references_with_SAM_segm/references_visualisations/.

| Obrazek referencyjny 1-shot dla PTAKA 🐦 (automatycznie segmentowany przez SAM) | Obrazek referencyjny 1-shot dla ŁODZI ⛵ (automatycznie segmentowany przez SAM) | |:---------------------------------:|:----------------------------------:| | | |

0.2 Konwersja anotacji coco do pliku 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. Wypełnij pamięć referencjami

Najpierw zdefiniuj przydatne zmienne i utwórz folder na wyniki. Aby poprawnie wyświetlać etykiety, nazwy klas powinny być uporządkowane według identyfikatora kategorii, tak jak występują w pliku json. Np. bird ma identyfikator kategorii 16, boat ma identyfikator kategorii 9. Zatem 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. Bank pamięci po przetworzeniu

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 Wizualizacja pamięci po przetworzeniu końcowym

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. Wnioskowanie na obrazach docelowych

Jeśli ONLINE_VIS jest ustawione na True, wyniki predykcji zostaną zapisane w results_analysis/my_custom_dataset/ i wyświetlone podczas obliczania. UWAGA: uruchamianie z wizualizacją online jest znacznie wolniejsze.

Możesz swobodnie zmieniać próg punktowy VIS_THR, aby zobaczyć więcej lub mniej wyodrębnionych instancji.

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

Wyniki

Metryki wydajności (przy dokładnie tych samych parametrach jak powyższe polecenia) powinny być następujące:

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

Kliknij obrazy, aby powiększyć ⬇️

| Obraz docelowy z łodziami ⛵ (lewy GT, prawe predykcje) | Obraz docelowy z ptakami 🐦 (lewy GT, prawe predykcje) | |:----------------------:|:----------------------:| | | |

| Obraz docelowy z łodziami i ptakami ⛵🐦 (lewy GT, prawe predykcje) | Obraz docelowy bez łodzi i ptaków 🚫 (lewy GT, prawe predykcje) | |:---------------------------------:|:----------------------------------:| | | |

🔬 Analizy ablacyjne

Ablacja backbone

Aby ocenić transferowalność naszej metody na różnych modelach bazowych, zastępujemy zarówno enkoder semantyczny (DINOv2), jak i segmentator oparty na SAM kilkoma alternatywami.

Ablacja enkodera semantycznego:

# 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

Analiza segmentera:

# 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

Ocena VLM na zbiorze danych COCO z niewielką liczbą próbek

Oceniamy QWEN VLM na zbiorze danych COCO z niewielką liczbą próbek.

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

Heurystyki obrazów referencyjnych

Aby zrozumieć, dlaczego różne obrazy referencyjne prowadzą do zmienności wydajności, analizujemy statystyczne właściwości adnotacji nowych klas COCO.

#### ANALIZA

Badamy trzy cechy adnotacji: (1) powierzchnia maski (rozmiar obiektu), (2) położenie środka maski oraz (3) odległość od krawędzi obrazu.

# 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

[WYJŚCIE] Rozkład powierzchni maski

[WYJŚCIE] Gęstość środków obwiedni (bbox)

[WYJŚCIE] Histogramy odległości od krawędzi obwiedni (bbox)

#### WYBÓR

Próbkujemy 100 zróżnicowanych obrazów referencyjnych na klasę, w sposób jawny obejmujący zakres rozmiarów masek, środków i odległości od krawędzi. Każda referencja jest oceniana na ustalonym, zredukowanym podzestawie walidacyjnym.

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

#### WYNIKI

Analizujemy, jak wyniki detekcji korelują z cechami obrazu referencyjnego (wielkość maski, pozycja środka, odległość od krawędzi).

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] Wykresy słupkowe. Wpływ powierzchni maski (lewo) i wycentrowania (prawo) na wydajność

[OUTPUT] Mapy cieplne. Dwuwymiarowe mapy wyników wydajności w funkcji położenia środka maski

[OUTPUT] Wydajność obrazu referencyjnego vs. powierzchnia maski dla wszystkich nowych klas COCO

Degradacja obrazu referencyjnego

Oceniamy naszą metodę przy stopniowo degradowanych obrazach referencyjnych poprzez nakładanie rosnących poziomów rozmycia Gaussa.

# 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

Podobieństwo cech

Skrypt do wizualizacji podobieństwa cech pomiędzy obrazami referencyjnymi a obrazami docelowymi.

Generuje podobieństwo pojedynczych cech (cechy ścieżki) oraz podobieństwo oparte na prototypach (zagregowane cechy).

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

Wykresy T-SNE (separowalność cech DINOv2)

t-SNE cech DINOv2 pokazuje wyraźne rozdzielenie dla klas niepodobnych, ale duże nakładanie się dla klas podobnych, sugerując, że pomyłki wynikają z geometrii cech backbone, a nie z doboru prototypów.

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

🛠️ Pomocniki

Wizualizacja pamięci

dodaj obraz feature_comparison_small.png tutaj

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

Zmień rozmiar obrazów na 512x512 (spraw, aby obrazy były kwadratowe)

Aby zmienić rozmiar obrazów na 512x512 i zapisać je do nowego katalogu, uruchom następujące polecenie. Dotyczy to rysunków do publikacji.

python no_time_to_train/make_plots/paper_fig_square_imgs.py

Rozmiar modelu i pamięć

Aby obliczyć rozmiar modelu i pamięć, uruchom następujące polecenie.

🌍 Zbiory danych EO

Skrypty ewaluacyjne (zbiory EO)

Skrypty ewaluacyjne znajdują się w katalogu scripts/EO. Zbiory danych EO wykorzystują skrypt ./scripts/EO/EO_template.sh do uruchamiania ewaluacji.

Każde uruchomienie eksperymentu EO jest zapisywane w katalogu ./EO_results. W folderze eksperymentu przechowywane są:

• Plik summary.txt z konfiguracją i czasem trwania eksperymentu.
• Wizualizacje predykcji na zbiorze testowym (folder results_analysis).
• Wizualizacje pamięci (folder memory_vis).
• Plik pickle z kilka-przykładową adnotacją.
• Punkty kontrolne modelu (jeśli nie zostały usunięte).

Wykresy i tabele

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