ODPure: Purificação de Backdoor para Detecção de Objetos via Consenso de Corrupção em Conjunto

A primeira defesa de purificação em estágio de entrada, caixa-preta, adaptada para detectores de objetos contra ataques de backdoor.

📖 Visão Geral

ODPure é o primeiro framework de purificação em estágio de entrada, caixa-preta, adaptado para defender detectores de objetos contra ataques de backdoor. Ele operacionaliza um novo paradigma de Corrupção-Reconstrução-Seleção (CRS) que:

1. Corrompe imagens de entrada com perturbações diversas para interromper padrões de gatilho
2. Reconstrói características estruturais refinadas usando priors de difusão generativa
3. Seleciona detecções de alta confiança via votação de consenso espacial

ODPure neutraliza efetivamente diversos ataques de backdoor (reduzindo a Taxa de Sucesso do Ataque para até 0,0%) enquanto preserva a utilidade de detecção limpa, alcançando relações de compromisso defesa-utilidade superiores às defesas existentes.

🔑 Principais Características

• Defesa Caixa-Preta: Não requer internos do modelo, gradientes ou arquiteturas
• Agnóstico ao Modelo: Funciona com qualquer detector de objetos (YOLO, Faster R-CNN, etc.)
• Defesa Multi-Ataque: Lida com tipos de ataque OMA, ODA e OGA
• Zero-Shot: Nenhum conhecimento prévio dos padrões de gatilho é necessário
• Percepção Contínua: Mantém a continuidade operacional do fluxo sem descartar dados

📋 Requisitos

Requisitos de Sistema

• Python 3.8+
• CUDA 11.7+ (para aceleração por GPU)
• 16GB+ de memória de GPU recomendado

Dependências 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

Configuração do Ambiente 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

📦 Baixar Pesos Pré-Treinados

Antes de executar o módulo de Reconstrução, você precisa baixar os pesos do modelo pré-treinado:

Pesos Necessários

Modelo	Descrição	Download
DiffBIR v2.1	Modelo principal de restauração	HuggingFace
Stable Diffusion	Priors de difusão latente	HuggingFace
LLaVA	Legendador de visão-linguagem	HuggingFace
RAM	Modelo de Reconhecimento-Aware	GitHub Release

Passos de Instalação

1. Crie o diretório de pesos:

mkdir -p Method/Reconstruction/weights

2. Baixe e coloque os pesos seguindo as instruções nos respectivos repositórios dos modelos.

3. Atualize os arquivos de configuração em Method/Reconstruction/configs/ para apontar para os pesos baixados.

🏗️ Estrutura do Projeto

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

🚀 Início Rápido

Opção A: Pipeline Ponta-a-Ponta em Uma Execução (Recomendado)

O ponto de entrada recomendado é run_pipeline.sh, que encadeia os três estágios do 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

O script executa:

1. Estágio 1 (Corrupção) – gera 45 variantes corrompidas
2. Estágio 2 (Reconstrução) – DiffBIR v2.1 com legendador LLaVA
3. Estágio 3 (Seleção) – votação de consenso espacial DBSCAN

As detecções purificadas finais são gravadas em <OUTPUT_DIR>/final/.

Opção B: Executar Cada Estágio Manualmente

Use isto se você quiser inspecionar / substituir etapas intermediárias.

Estágio 1: Corrupção

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

Estágio 2: Reconstrução

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

Estágio 3: Seleção (Votação 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

📊 Avaliação

Passo 1: Ativar o Ambiente

conda activate odpure

Passo 2: Executar o Detector em Três Divisões