ODPure: Purificación de puertas traseras para detección de objetos mediante consenso de corrupción por ensamble

La primera defensa de purificación de caja negra en la etapa de entrada diseñada específicamente para detectores de objetos contra ataques de puerta trasera.

📖 Descripción general

ODPure es el primer marco de purificación de caja negra en la etapa de entrada diseñado específicamente para defender detectores de objetos contra ataques de puerta trasera. Operacionaliza un novedoso paradigma de Corrupción-Reconstrucción-Selección (CRS) que:

1. Corrompe imágenes de entrada con diversas perturbaciones para interrumpir los patrones de activación
2. Reconstruye características estructurales de grano fino utilizando priors de difusión generativa
3. Selecciona detecciones de alta confianza mediante votación de consenso espacial

ODPure neutraliza eficazmente diversos ataques de puerta trasera (reduciendo la Tasa de Éxito del Ataque hasta un 0.0%) mientras preserva la utilidad de detección limpia, logrando relaciones de compromiso defensa-utilidad superiores a las defensas existentes.

🔑 Características clave

• Defensa de caja negra: No requiere acceso a los internos del modelo, gradientes ni arquitecturas
• Agnóstico al modelo: Funciona con cualquier detector de objetos (YOLO, Faster R-CNN, etc.)
• Defensa multiataque: Maneja los tipos de ataque OMA, ODA y OGA
• Zero-Shot: No requiere conocimiento previo de los patrones de activación
• Percepción continua: Mantiene la continuidad operativa del flujo sin descartar datos

📋 Requisitos

Requisitos del sistema

• Python 3.8+
• CUDA 11.7+ (para aceleración por GPU)
• Se recomienda 16GB+ de memoria GPU

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

Configuración del entorno Conda (Recomendado)

# 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

📦 Descargar pesos preentrenados

Antes de ejecutar el módulo de Reconstrucción, debe descargar los pesos del modelo preentrenado:

Pesos requeridos

Modelo	Descripción	Descarga
DiffBIR v2.1	Modelo de restauración principal	HuggingFace
Stable Diffusion	Priors de difusión latente	HuggingFace
LLaVA	Generador de descripciones visión-lenguaje	HuggingFace
RAM	Modelo de Reconocimiento Consciente	GitHub Release

Pasos de instalación

1. Cree el directorio de pesos:

mkdir -p Method/Reconstruction/weights

2. Descargue y coloque los pesos siguiendo las instrucciones en los repositorios de los modelos respectivos.

3. Actualice los archivos de configuración en Method/Reconstruction/configs/ para que apunten a los pesos descargados.

🏗️ Estructura del proyecto

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

🚀 Inicio rápido

Opción A: Pipeline integral de un solo paso (Recomendado)

El punto de entrada recomendado es run_pipeline.sh, que encadena las tres etapas de 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

El script realiza:

1. Etapa 1 (Corrupción) – genera 45 variantes corrompidas
2. Etapa 2 (Reconstrucción) – DiffBIR v2.1 con generador de descripciones LLaVA
3. Etapa 3 (Selección) – votación de consenso espacial DBSCAN

Las detecciones purificadas finales se escriben en <OUTPUT_DIR>/final/.

Opción B: Ejecutar cada etapa manualmente

Use esto si desea inspeccionar / reemplazar pasos intermedios.

Etapa 1: Corrupción

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

Etapa 2: Reconstrucción

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

Etapa 3: Selección (Votación 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

📊 Evaluación

Paso 1: Activar el entorno

conda activate odpure

Paso 2: Ejecutar el detector en tres divisiones