🌐 भाषा

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

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

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

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

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

🚨 अपडेट (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 एनोटेशन को pickle फ़ाइल में बदलें
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

3. लक्ष्य इमेजों पर अनुमान

यदि 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/ में सहेजे जाते हैं। ध्यान दें कि हमारी विधि झूठे नकारात्मक मामलों के लिए काम करती है, यानी वे छवियाँ जिनमें वांछित वर्गों की कोई भी इकाई नहीं होती है।

छवियों पर क्लिक करें बड़ा देखने के लिए ⬇️

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

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

📚 संदर्भ

यदि आप इस कार्य का उपयोग करते हैं, तो कृपया हमें उद्धृत करें:

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