ODPure : Purification de porte dérobée pour la détection d'objets via consensus de corruption d'ensemble

La première défense de purification en boîte noire au stade de l'entrée, conçue pour les détecteurs d'objets contre les attaques par porte dérobée.

📖 Aperçu

ODPure est le premier framework de purification en boîte noire au stade de l'entrée, conçu pour défendre les détecteurs d'objets contre les attaques par porte dérobée. Il met en œuvre un nouveau paradigme Corruption-Reconstruction-Sélection (CRS) qui :

1. Corrompt les images d'entrée avec diverses perturbations pour perturber les motifs de déclenchement
2. Reconstruit les caractéristiques structurelles fines à l'aide de priors de diffusion génératifs
3. Sélectionne les détections à haute confiance via un vote de consensus spatial

ODPure neutralise efficacement diverses attaques par porte dérobée (réduisant le taux de succès de l'attaque jusqu'à 0,0 %) tout en préservant l'utilité de détection propre, offrant des compromis défense-utilité supérieurs aux défenses existantes.

🔑 Caractéristiques principales

• Défense en boîte noire : Aucun besoin des internes du modèle, des gradients ou des architectures
• Agnostique au modèle : Fonctionne avec n'importe quel détecteur d'objets (YOLO, Faster R-CNN, etc.)
• Défense multi-attaques : Gère les types d'attaques OMA, ODA et OGA
• Zero-Shot : Aucune connaissance préalable des motifs de déclenchement requise
• Perception continue : Maintient la continuité du flux opérationnel sans rejeter de données

📋 Prérequis

Configuration système requise

• Python 3.8+
• CUDA 11.7+ (pour l'accélération GPU)
• 16 Go+ de mémoire GPU recommandés

Dépendances 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

Configuration de l'environnement Conda (recommandé)

# 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

📦 Téléchargement des poids pré-entraînés

Avant d'exécuter le module de Reconstruction, vous devez télécharger les poids du modèle pré-entraîné :

Poids requis

Modèle	Description	Téléchargement
DiffBIR v2.1	Modèle de restauration principal	HuggingFace
Stable Diffusion	Priors de diffusion latente	HuggingFace
LLaVA	Légendeur vision-langage	HuggingFace
RAM	Modèle de reconnaissance consciente	GitHub Release

Étapes d'installation

1. Créez le répertoire des poids :

mkdir -p Method/Reconstruction/weights

2. Téléchargez et placez les poids en suivant les instructions des dépôts de modèles respectifs.

3. Mettez à jour les fichiers de configuration dans Method/Reconstruction/configs/ pour pointer vers vos poids téléchargés.

🏗️ Structure du projet

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

🚀 Démarrage rapide

Option A : Pipeline de bout en bout en une seule fois (recommandé)

Le point d'entrée recommandé est run_pipeline.sh, qui enchaîne les trois étapes 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

Le script effectue :

1. Étape 1 (Corruption) – génère 45 variantes corrompues
2. Étape 2 (Reconstruction) – DiffBIR v2.1 avec légendeur LLaVA
3. Étape 3 (Sélection) – vote de consensus spatial DBSCAN

Les détections purifiées finales sont écrites dans <OUTPUT_DIR>/final/.

Option B : Exécuter chaque étape manuellement

Utilisez cette option si vous souhaitez inspecter / remplacer les étapes intermédiaires.

Étape 1 : Corruption

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

Étape 2 : Reconstruction

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

Étape 3 : Sélection (vote 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

📊 Évaluation

Étape 1 : Activer l'environnement

conda activate odpure

Étape 2 : Exécuter le détecteur sur trois divisions