ODPure: एन्सेम्बल करप्शन कॉन्सेंसस के माध्यम से ऑब्जेक्ट डिटेक्शन के लिए बैकडोर प्यूरीफिकेशन

बैकडोर हमलों के विरुद्ध ऑब्जेक्ट डिटेक्टरों के लिए तैयार किया गया पहला इनपुट-स्टेज ब्लैक-बॉक्स प्यूरीफिकेशन डिफेंस।

📖 अवलोकन

ODPure पहला इनपुट-स्टेज, ब्लैक-बॉक्स प्यूरीफिकेशन फ्रेमवर्क है जो ऑब्जेक्ट डिटेक्टरों को बैकडोर हमलों से बचाने के लिए तैयार किया गया है। यह एक नए Corruption-Reconstruction-Selection (CRS) प्रतिमान को क्रियान्वित करता है जो:

1. ट्रिगर पैटर्न को बाधित करने के लिए इनपुट छवियों को विविध विकृतियों के साथ करप्ट करता है
2. जनरेटिव डिफ्यूजन प्रायर्स का उपयोग करके सूक्ष्म संरचनात्मक विशेषताओं का पुनर्निर्माण करता है
3. स्थानिक सर्वसम्मति मतदान के माध्यम से उच्च-विश्वास वाले डिटेक्शनों का चयन करता है

ODPure विविध बैकडोर हमलों को प्रभावी ढंग से निष्क्रिय करता है (Attack Success Rate को 0.0% तक कम करता है) जबकि स्वच्छ डिटेक्शन उपयोगिता को संरक्षित रखता है, और मौजूदा डिफेंसों की तुलना में बेहतर डिफेंस-उपयोगिता ट्रेड-ऑफ प्राप्त करता है।

🔑 मुख्य विशेषताएँ

• ब्लैक-बॉक्स डिफेंस: मॉडल इंटरनल्स, ग्रेडिएंट्स, या आर्किटेक्चर की आवश्यकता नहीं
• मॉडल-अज्ञेय: किसी भी ऑब्जेक्ट डिटेक्टर के साथ काम करता है (YOLO, Faster R-CNN, आदि)
• मल्टी-अटैक डिफेंस: OMA, ODA, और OGA हमला प्रकारों को संभालता है
• ज़ीरो-शॉट: ट्रिगर पैटर्न का कोई पूर्व ज्ञान आवश्यक नहीं
• सतत धारणा: डेटा को त्यागे बिना परिचालन स्ट्रीम निरंतरता बनाए रखता है

📋 आवश्यकताएँ

सिस्टम आवश्यकताएँ

• Python 3.8+
• CUDA 11.7+ (GPU त्वरण के लिए)
• 16GB+ GPU मेमोरी की सिफारिश की जाती है

Python निर्भरताएँ

# Core dependencies
torch>=1.13.0
torchvision>=0.14.0
numpy>=1.21.0
Pillow>=9.0.0
opencv-python>=4.5.0

# Diffusion models
diffusers>=0.14.0
transformers>=4.25.0
accelerate>=0.20.0

# Evaluation
scikit-learn>=1.2.0  # For DBSCAN clustering
scipy>=1.9.0

# Data processing
pyyaml>=6.0
tqdm>=4.64.0

Conda एनवायरनमेंट सेटअप (अनुशंसित)

# Create conda environment
conda create -n odpure python=3.9 -y
conda activate odpure

# Install PyTorch with CUDA
conda install pytorch torchvision pytorch-cuda=11.7 -c pytorch -c nvidia

# Install other dependencies
pip install -r requirements.txt

📦 प्रीट्रेन्ड वेट्स डाउनलोड करें

Reconstruction मॉड्यूल चलाने से पहले, आपको प्रीट्रेन्ड मॉडल वेट्स डाउनलोड करने होंगे:

आवश्यक वेट्स

Model	Description	Download
DiffBIR v2.1	Main restoration model	HuggingFace
Stable Diffusion	Latent diffusion priors	HuggingFace
LLaVA	Vision-language captioner	HuggingFace
RAM	Recognition-Aware Model	GitHub Release

इंस्टॉलेशन चरण

1. वेट्स डायरेक्टरी बनाएँ:

mkdir -p Method/Reconstruction/weights

2. संबंधित मॉडल रिपॉजिटरी में दिए गए निर्देशों का पालन करते हुए वेट्स डाउनलोड करें और रखें।

3. अपने डाउनलोड किए गए वेट्स की ओर इंगित करने के लिए Method/Reconstruction/configs/ में कॉन्फ़िग फ़ाइलों को अपडेट करें।

🏗️ प्रोजेक्ट संरचना

ODPure/
├── attack_script/              # Backdoor attack implementations
│   ├── COCO_chessboard_29x29_OMA.py     # Object Misclassification (Chessboard)
│   ├── COCO_chessboard_29x29_ODA.py     # Object Disappearance Attack (Chessboard)
│   ├── COCO_chessboard_9x9_OGA.py      # Object Generation Attack (Chessboard)
│   ├── COCO_poke_15x15_OMA.py          # OMA (Poké Ball)
│   ├── COCO_poke_15x15_ODA.py          # ODA (Poké Ball)
│   ├── COCO_poke_15x15_OGA.py          # OGA (Poké Ball)
│   ├── COCO_white_15x15_OMA.py         # OMA (Solid White)
│   ├── COCO_white_15x15_ODA.py         # ODA (Solid White)
│   └── COCO_white_15x15_OGA.py         # OGA (Solid White)
│
├── Method/                     # Core defense methodology
│   ├── corruptions/           # Image corruption module
│   │   ├── imagecorruption.py # Corruption functions
│   │   └── multiprocess_imagecorruption.py  # Parallel processing
│   │
│   ├── Reconstruction/         # Diffusion-based restoration
│   │   ├── inference.py       # Main inference script
│   │   ├── diffbir/           # DiffBIR model implementation
│   │   ├── llava/             # LLaVA captioner
│   │   ├── ram/               # Recognition-Aware Model
│   │   ├── configs/           # Model configurations
│   │   └── weights/           # Model weights (download separately)
│   │
│   └── dbscan_vote_new.py     # DBSCAN clustering & voting
│
├── evaluation/                 # Evaluation metrics
│   ├── OMA_ASR_new.py         # OMA Attack Success Rate
│   ├── OMA_mAP.py             # OMA Mean Average Precision
│   ├── ODA_ASR_new.py         # ODA Attack Success Rate
│   ├── ODA_mAP.py             # ODA Mean Average Precision
│   ├── OGA_ASR_new.py         # OGA Attack Success Rate
│   ├── OGA_mAP.py             # OGA Mean Average Precision
│   ├── val_OMA.py             # YOLO validation for OMA
│   ├── val_ODA.py             # YOLO validation for ODA
│   └── val_OGA.py             # YOLO validation for OGA
│
├── data_format_conversion/    # Data format utilities
│   ├── voc2yolo.py            # VOC to YOLO format conversion
│   ├── cocotoyolo.py          # COCO to YOLO format conversion
│   └── select_coco_val_attack_information.py
│
├── ablation_study/            # Ablation experiments
│   ├── multiprocess_imagecorruption.py
│   ├── random_select_corruption.py
│   └── select_specific_corruption.py
│
├── run_pipeline.sh            # One-shot CRS pipeline runner
└── README.md                 # This file

🚀 त्वरित शुरुआत

विकल्प A: वन-शॉट एंड-टू-एंड पाइपलाइन (अनुशंसित)

अनुशंसित प्रवेश बिंदु run_pipeline.sh है, जो तीन CRS चरणों को कैस्केड करता है:

# Defaults: GPU=0, INPUT=inputs/demo/bid, OUTPUT=results/v2.1_demo_bid, ATTACK=ODA
bash run_pipeline.sh

# Custom arguments: GPU_ID INPUT_DIR OUTPUT_DIR ATTACK
bash run_pipeline.sh 0 inputs/coco_oda results/oda ODA
bash run_pipeline.sh 1 inputs/coco_oma results/oma OMA
bash run_pipeline.sh 2 inputs/coco_oga results/oga OGA

स्क्रिप्ट निम्नलिखित करती है:

1. चरण 1 (करप्शन) – 45 करप्टेड वेरिएंट उत्पन्न करता है
2. चरण 2 (पुनर्निर्माण) – LLaVA कैप्शनर के साथ DiffBIR v2.1
3. चरण 3 (चयन) – DBSCAN स्थानिक सर्वसम्मति मतदान

अंतिम शुद्ध किए गए डिटेक्शन <OUTPUT_DIR>/final/ में लिखे जाते हैं।

विकल्प B: प्रत्येक चरण को मैन्युअल रूप से चलाएँ

यदि आप मध्यवर्ती चरणों का निरीक्षण / प्रतिस्थापन करना चाहते हैं तो इसका उपयोग करें।

चरण 1: करप्शन

python Method/corruptions/multiprocess_imagecorruption.py \
    --input_dir /path/to/input/images \
    --output_dir /path/to/corrupted/images \
    --num_corruptions 45 \
    --num_workers 8

चरण 2: पुनर्निर्माण

python Method/Reconstruction/inference.py \
    --task denoise \
    --upscale 2 \
    --version v2.1 \
    --captioner llava \
    --cfg_scale 6 \
    --noise_aug 1 \
    --input /path/to/corrupted/images \
    --output /path/to/restored/images \
    --batch_size 32 \
    --device cuda

चरण 3: चयन (DBSCAN मतदान)

python Method/dbscan_vote_new.py \
    --folder_purs /path/to/restored/detections \
    --temp /path/to/temp \
    --output_path /path/to/final/detections \
    --eps 0.5 \
    --min_samples 10

📊 मूल्यांकन

चरण 1: एनवायरनमेंट सक्रिय करें

conda activate odpure

चरण 2: तीन स्प्लिट्स पर डिटेक्टर चलाएँ

# Run on poisoned inputs (before defense)
python evaluation/val_ODA.py \
    --weights runs/train/exp/weights/last.pt \
    --data data/ODA_poison.yaml \
    --img 640 --iou-thres 0.65 --conf-thres 0.5 \
    --save-txt --save-conf \
    --project results/poisoned_val_txt