🌐 भाषा

🚀 ट्रेनिंग का समय नहीं है!

प्रशिक्षण-मुक्त संदर्भ-आधारित इंस्टेंस सेगमेंटेशन

स्टेट-ऑफ-द-आर्ट (कोड के साथ पेपर्स) _SOTA 1-shot_ | -21CBCE?style=flat&logo=paperswithcode)

_SOTA 10-shot_ | -21CBCE?style=flat&logo=paperswithcode)

_SOTA 30-shot_ | -21CBCE?style=flat&logo=paperswithcode)

🚨 अपडेट (5 फरवरी 2026): पेपर की पांडुलिपि को व्यापक एब्लेशन अध्ययन, दृश्यांकन और अतिरिक्त प्रयोगों के साथ अपडेट किया गया है।

🚨 अपडेट (22 जुलाई 2025): कस्टम डेटासेट्स के लिए निर्देश जोड़े गए हैं!

🔔 अपडेट (16 जुलाई 2025): कोड को निर्देशों के साथ अपडेट किया गया है!

📋 विषय-सूची

🎯 मुख्य आकर्षण
📜 सारांश
🧠 संरचना
🛠️ इंस्टॉलेशन निर्देश
1. रिपॉजिटरी क्लोन करें
2. कोंडा एनवायरनमेंट बनाएं
3. SAM2 और DINOv2 इंस्टॉल करें
4. डेटासेट डाउनलोड करें
5. SAM2 और DINOv2 चेकपॉइंट्स डाउनलोड करें
📊 इनफेरेंस कोड: Few-shot COCO में 30-shot SOTA परिणाम दोहराएं
0. रेफरेंस सेट बनाएं
1. मेमोरी को रेफरेंस से भरें
2. मेमोरी बैंक का पोस्ट-प्रोसेस करें
3. लक्ष्य इमेज पर इनफेरेंस करें

परिणाम
🔍 कस्टम डेटासेट
0. कस्टम डेटासेट तैयार करें ⛵🐦
0.1 यदि केवल bbox एनोटेशन उपलब्ध हैं
0.2 coco एनोटेशन को पिकल फ़ाइल में बदलें
1. रेफरेंस से मेमोरी भरें
2. मेमोरी बैंक का पोस्ट-प्रोसेस करें
📚 संदर्भ

🎯 मुख्य बातें

💡 प्रशिक्षण-मुक्त: न फाइन-ट्यूनिंग, न प्रॉम्प्ट इंजीनियरिंग—सिर्फ एक संदर्भ छवि।
🖼️ संदर्भ-आधारित: केवल कुछ उदाहरणों से नए वस्तुओं का विभाजन करें।
🔥 SOTA प्रदर्शन: COCO, PASCAL VOC, और Cross-Domain FSOD पर पिछले प्रशिक्षण-मुक्त तरीकों से बेहतर प्रदर्शन।

लिंक:

📜 सारांश

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. कॉन्डा वातावरण बनाएं

हम आवश्यक पैकेजों के साथ एक कॉन्डा वातावरण बनाएंगे।

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

3. SAM2 और DINOv2 स्थापित करें

हम SAM2 और DINOv2 को स्रोत से स्थापित करेंगे।

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

4. डेटासेट डाउनलोड करें

कृपया COCO डेटासेट डाउनलोड करें और इसे data/coco में रखें

5. SAM2 और DINOv2 चेकपॉइंट डाउनलोड करें

हम पेपर में उपयोग किए गए वही SAM2 चेकपॉइंट डाउनलोड करेंगे। (ध्यान दें, हालांकि, SAM2.1 चेकपॉइंट पहले से उपलब्ध हैं और बेहतर प्रदर्शन कर सकते हैं।)

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

📊 अनुमान कोड

⚠️ अस्वीकरण: यह अनुसंधान कोड है — इसमें थोड़ी अव्यवस्था हो सकती है!

Few-shot COCO में 30-shot SOTA परिणामों की पुनरावृत्ति

उपयोगी वेरिएबल्स परिभाषित करें और परिणामों के लिए एक फ़ोल्डर बनाएं:

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. संदर्भ सेट बनाएं

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

#### 1. मेमोरी को रेफरेंस के साथ भरें

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. पोस्ट-प्रोसेस मेमोरी बैंक

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. लक्ष्य चित्रों पर अनुकरण (इन्फेरेंस)

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

स्कोर थ्रेशोल्ड score_thr पैरामीटर को समायोजित करने के लिए, तर्क जोड़ें (उदाहरण के लिए, सभी उदाहरणों को विज़ुअलाइज़ करना जिनका स्कोर 0.4 से अधिक है):

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

छवियाँ अब results_analysis/few_shot_classes/ में सहेजी जाएँगी। बाएँ ओर की छवि में ग्राउंड ट्रुथ दिखाई गई है, दाएँ ओर की छवि में हमारे प्रशिक्षण-मुक्त विधि द्वारा प्राप्त विभाजित इंस्टेंस दिखाई गई हैं।

ध्यान दें कि इस उदाहरण में हम few_shot_classes विभाजन का उपयोग कर रहे हैं, अतः, हमें केवल इसी विभाजन की कक्षाओं के विभाजित इंस्टेंस देखने की अपेक्षा करनी चाहिए (COCO की सभी कक्षाएँ नहीं)।

#### परिणाम

सत्यापन सेट की सभी छवियों को चलाने के बाद, आपको प्राप्त होना चाहिए:

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

🔍 कस्टम डेटासेट

हम अपने पाइपलाइन को कस्टम डेटासेट पर चलाने के लिए निर्देश प्रदान करते हैं। एनोटेशन फॉर्मेट हमेशा COCO फॉर्मेट में ही होता है।

संक्षेप में; यदि आप सीधे कस्टम डेटासेट्स पर पूरी पाइपलाइन कैसे चलाएं देखना चाहते हैं, तो scripts/matching_cdfsod_pipeline.sh देखें, साथ ही CD-FSOD डेटासेट्स के उदाहरण स्क्रिप्ट्स (जैसे scripts/dior_fish.sh) भी देखें।

0. एक कस्टम डेटासेट तैयार करें ⛵🐦

मान लीजिए हम एक कस्टम डेटासेट में नावें⛵ और पक्षी🐦 का पता लगाना चाहते हैं। हमारी विधि का उपयोग करने के लिए आपको आवश्यकता होगी:

प्रत्येक श्रेणी के लिए कम से कम 1 एनोटेटेड रेफरेंस इमेज (जैसे नाव के लिए 1 और पक्षी के लिए 1 रेफरेंस इमेज)
कई लक्ष्य इमेज जिनमें हमारे वांछित श्रेणियों के इंस्टेंस मिल सकें।

हमने COCO इमेजेस के साथ कस्टम डेटासेट बनाने के लिए एक टॉय स्क्रिप्ट तैयार की है, 1-शॉट सेटिंग के लिए।

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-शॉट):

0.1 यदि केवल bbox एनोटेशन उपलब्ध हैं

हम एक स्क्रिप्ट भी प्रदान करते हैं जो SAM2 का उपयोग करके इंस्टेंस-लेवल सेगमेंटेशन मास्क उत्पन्न करती है। यह तब उपयोगी है जब आपके पास संदर्भ छवियों के लिए केवल बॉक्स एनोटेशन उपलब्ध हों।

# 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

इंस्टेंस-स्तरीय सेगमेंटेशन मास्क के साथ संदर्भ छवियाँ (gt बॉक्स से SAM2 द्वारा उत्पन्न, 1-शॉट):

उत्पन्न सेगमेंटेशन मास्क का दृश्यावलोकन data/my_custom_dataset/annotations/custom_references_with_SAM_segm/references_visualisations/ में सहेजा गया है।

| BIRD 🐦 के लिए 1-शॉट संदर्भ छवि (SAM द्वारा स्वचालित सेगमेंटेशन के साथ) | BOAT ⛵ के लिए 1-शॉट संदर्भ छवि (SAM द्वारा स्वचालित सेगमेंटेशन के साथ) | |:---------------------------------:|:----------------------------------:| | bird_1_with_SAM_segm | boat_1_with_SAM_segm |

0.2 कोको एनोटेशन को पिकल फ़ाइल में बदलें

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. मेमोरी को संदर्भों से भरें

सबसे पहले, उपयोगी वेरिएबल्स परिभाषित करें और परिणामों के लिए एक फ़ोल्डर बनाएं। लेबल्स का सही दृश्यकरण सुनिश्चित करने के लिए, वर्ग नामों को उसी क्रम में रखना चाहिए जैसा कि वे json फ़ाइल में category id के अनुसार हैं। उदाहरण के लिए, bird का category id 16 है, boat का category id 9 है। अतः, 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

चरण 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. पोस्ट-प्रोसेस मेमोरी बैंक

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 पोस्ट-प्रोसेस्ड मेमोरी बैंक का दृश्यांकन करें

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

मेमोरी बैंक इमेजों के लिए PCA और K-means विज़ुअलाइज़ेशन results_analysis/memory_vis/my_custom_dataset में संग्रहित हैं।

3. लक्ष्य इमेजों पर अनुकरण (Inference)

यदि ONLINE_VIS को True पर सेट किया गया है, तो भविष्यवाणी परिणाम results_analysis/my_custom_dataset/ में सहेजे जाएंगे और जैसे-जैसे गणना होती है, वैसे-वैसे प्रदर्शित होंगे। ध्यान दें कि ऑनलाइन विज़ुअलाइज़ेशन के साथ चलाना काफी धीमा होता है।

अधिक या कम खंडित इंस्टेंस देखने के लिए आप स्कोर थ्रेशोल्ड VIS_THR को स्वतंत्र रूप से बदल सकते हैं।

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

परिणाम

प्रदर्शन मीट्रिक (ऊपर दिए गए कमांड्स के समान सटीक पैरामीटर के साथ) निम्नलिखित होनी चाहिए:

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

दृश्य परिणाम results_analysis/my_custom_dataset/ में सहेजे गए हैं। ध्यान दें कि हमारी विधि झूठे नकारात्मक (false negatives) के लिए काम करती है, अर्थात् वे चित्र जिनमें वांछित श्रेणियों के कोई उदाहरण नहीं होते।

चित्रों पर क्लिक करें विस्तार के लिए ⬇️

| नावों वाले लक्ष्य चित्र ⛵ (बाएँ GT, दाएँ पूर्वानुमान) | पक्षियों वाले लक्ष्य चित्र 🐦 (बाएँ GT, दाएँ पूर्वानुमान) | |:----------------------:|:----------------------:| | 000000459673 | 000000407180 |

| नाव और पक्षी वाले लक्ष्य चित्र ⛵🐦 (बाएँ GT, दाएँ पूर्वानुमान) | नाव या पक्षी के बिना लक्ष्य चित्र 🚫 (बाएँ GT, दाएँ पूर्वानुमान) | |:---------------------------------:|:----------------------------------:| | 000000517410 | 000000460598 |

🔬 अपक्षरण (Ablations)

बैकबोन अपक्षरण

हमारी विधि की फाउंडेशन मॉडल्स में स्थानांतरण योग्यता का मूल्यांकन करने के लिए, हम सेमांटिक एनकोडर (DINOv2) और SAM-आधारित सेगमेंटर दोनों को कई विकल्पों से बदलते हैं।

सेमांटिक एनकोडर अपक्षरण:

# 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

सेगमेंटर एब्लेशन:

# 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

COCO कुछ-शॉट डेटासेट पर VLM मूल्यांकन

हम QWEN VLM का मूल्यांकन COCO कुछ-शॉट डेटासेट पर करते हैं।

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

संदर्भ छवि की युक्तियाँ

यह समझने के लिए कि अलग-अलग संदर्भ छवियाँ प्रदर्शन में बदलाव क्यों लाती हैं, हम COCO नए वर्ग एनोटेशन के सांख्यिकीय गुणों का विश्लेषण करते हैं।

#### विश्लेषण

हम तीन एनोटेशन विशेषताओं का अध्ययन करते हैं: (1) मास्क क्षेत्र (वस्तु का आकार), (2) मास्क केंद्र स्थान, और (3) छवि किनारों से दूरी।

निर्देश:

# 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] मास्क क्षेत्र वितरण

[OUTPUT] बॉक्स केंद्र घनत्व

[OUTPUT] बॉक्स किनारे दूरी हिस्टोग्राम

#### चयन

हम प्रति वर्ग 100 विविध संदर्भ छवियों का नमूना लेते हैं, जो स्पष्ट रूप से मास्क के आकार, केंद्र और किनारे की दूरी की रेंज को कवर करते हैं। प्रत्येक संदर्भ को एक नियत, कम किए गए वैधता उपसमुच्चय पर मूल्यांकित किया जाता है।

निर्देश:

सेटअप स्क्रिप्ट: scripts/1shot_ref_ablation/setup.sh:

प्रति वर्ग json फ़ाइल बनाएँ
किसी विशिष्ट वर्ग का विश्लेषण करें
विभिन्न हीयूरिस्टिक्स के साथ संदर्भ सेट बनाएँ

bash scripts/1shot_ref_ablation/setup.sh

स्क्रिप्ट चलाएं: scripts/1shot_ref_ablation/gpu*.sh:

प्रत्येक संदर्भ सेट के लिए पाइपलाइन चलाएं

# Example launch script that calls template script for each reference set
bash scripts/1shot_ref_ablation/gpu0.sh

#### परिणाम

हम विश्लेषण करते हैं कि डिटेक्शन स्कोर किस प्रकार संदर्भ छवि की विशेषताओं से संबंधित हैं (मास्क आकार, केंद्र स्थिति, किनारे की दूरी)।

निर्देश:

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] बारप्लॉट्स। प्रदर्शन पर मास्क क्षेत्र (बाएँ) और केंद्रितता (दाएँ) का प्रभाव

[OUTPUT] हीटमैप्स। मास्क-केंद्र स्थान के अनुसार प्रदर्शन के 2D स्कोर मैप

[OUTPUT] सभी COCO नवीन वर्गों के लिए संदर्भ-चित्र प्रदर्शन बनाम मास्क क्षेत्र

संदर्भ-चित्र क्षरण

हम अपने विधि का मूल्यांकन क्रमिक रूप से क्षरित संदर्भ चित्रों पर बढ़ते हुए गाउसियन ब्लर स्तर लागू करके करते हैं। ablation-blur

निर्देश:

# 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

फ़ीचर समानता

संदर्भ छवियों और लक्ष्य छवियों के बीच फ़ीचर समानता को देखने के लिए स्क्रिप्ट।

यह एकल-फ़ीचर समानता (पाथ फ़ीचर्स), और प्रोटोटाइप-आधारित समानता (समेकित फ़ीचर्स) उत्पन्न करता है। feature_similarity_small

निर्देश:

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

टी-एसएनई प्लॉट्स (DINOv2 फीचर पृथक्करण)

DINOv2 फीचर्स का टी-एसएनई असमान वर्गों के लिए स्पष्ट विभाजन दिखाता है, लेकिन समान वर्गों के लिए भारी ओवरलैप, जो संकेत करता है कि भ्रम बैकबोन फीचर ज्योमेट्री से उत्पन्न होता है न कि प्रोटोटाइप चयन से। tsne

निर्देश:

फीचर्स निकालें

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

🛠️ सहायक

मेमोरी को विज़ुअलाइज़ करें

यहाँ feature_comparison_small.png छवि जोड़ें

निर्देश

किसी दिए गए प्रयोग के लिए मेमोरी बैंक (PCA और K-means विज़ुअलाइज़ेशन) देखने के लिए निम्नलिखित कमांड को समायोजित करें।

संदर्भ छवि को क्रॉप किए गए मास्क के साथ/बिना विज़ुअलाइज़ करने के लिए DO_NOT_CROP को True/False पर सेट करें (no_time_to_train/models/Sam2MatchingBaseline_noAMG.py में)।

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

छवियों का आकार 512x512 में बदलें (छवियों को वर्गाकार बनाएं)

छवियों का आकार 512x512 में बदलने और उन्हें एक नए डायरेक्टरी में सहेजने के लिए, निम्न कमांड चलाएँ। यह पेपर के चित्रों के लिए है।

निर्देश:

python no_time_to_train/make_plots/paper_fig_square_imgs.py

मॉडल आकार और मेमोरी

मॉडल आकार और मेमोरी की गणना के लिए निम्नलिखित कमांड चलाएँ।

निर्देश:

मॉडल आकार और मेमोरी गणना के लिए no_time_to_train/models/Sam2MatchingBaseline_noAMG_model_and_memory.py देखें।

(सबसे आसान: अस्थायी रूप से Sam2MatchingBaseline_noAMG.py से बदलें, फिर वापस नाम बदलें।)

🌍 EO डेटासेट्स

मूल्यांकन स्क्रिप्ट्स (EO डेटासेट्स)

मूल्यांकन स्क्रिप्ट्स scripts/EO डायरेक्टरी में मिल सकती हैं। EO डेटासेट्स ./scripts/EO/EO_template.sh स्क्रिप्ट का उपयोग मूल्यांकन चलाने के लिए करते हैं।

प्रत्येक EO प्रयोग रन ./EO_results डायरेक्टरी के अंतर्गत सुरक्षित किया जाता है। प्रयोग फोल्डर में हम संग्रहित करते हैं:

configuration और रनटाइम के साथ summary.txt फाइल।
टेस्ट सेट पर prediction visualisations (results_analysis फोल्डर)।
मेमोरी visualisations (memory_vis फोल्डर)।
few-shot annotation pickle फाइल।
मॉडल के checkpoints (अगर साफ़ नहीं किए गए हों)।

चित्र और तालिकाएँ

चित्र और तालिकाएँ बनाने के लिए अतिरिक्त स्क्रिप्ट्स।

EO डेटासेट्स की सारांश लैटेक्स तालिका:

python scripts/convert_datasets/summary_table_datasets.py

EO डेटा सेट्स की LaTeX तालिका बनाएं:

python scripts/paper_figures/table_EO_results.py ./EO_results_no_heuristics

EO डेटा सेट्स की सटीकता प्लॉट:

python scripts/paper_figures/plot_EO_accuracy.py \
  --input-root ./EO_results \
  --output-root ./EO_results

EO डाटासेट्स पर ह्यूरिस्टिक्स के प्रभाव का सारांश:

python scripts/paper_figures/plot_EO_heuristic.py \
  --no-heuristics ./EO_results_no_heuristics \
  --heuristics ./EO_results

EO डेटा सेट्स का रनटाइम प्लॉट:

python scripts/paper_figures/plot_EO_runtime.py \
  --input-root ./EO_results \
  --output-root ./EO_results

पेपर के चित्र के लिए EO ग्रिड विज़ुअलाइजेशन उत्पन्न करें:

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