T-Backdoor

पेपर के लिए नमूना कोड: 'T-Backdoor: स्पाइक-प्रिज़र्विंग बैकडोर हमलों के लिए न्यूरोमॉर्फिक डेटा में टेम्पोरल रिडंडेंसी का दोहन'

सारांश

बैकडोर हमले डीप न्यूरल नेटवर्क (DNNs) के लिए एक गंभीर सुरक्षा खतरा हैं और स्पाइकिंग न्यूरल नेटवर्क (SNNs) के लिए अभी भी काफी हद तक अज्ञात हैं। मौजूदा हमले मुख्य रूप से स्पेटियोटेम्पोरल ट्रिगर्स पेश करते हैं जो जहर वाले नमूनों के स्पाइक वितरण में उनके स्वच्छ समकक्षों के सापेक्ष विचलन उत्पन्न करते हैं। इस सीमा को दूर करने के लिए, यह कार्य SNNs पर एक नए बैकडोर हमले का प्रस्ताव करता है, जिसे \textbf{T-Backdoor} कहा जाता है, जो विशुद्ध रूप से टेम्पोरल ट्रिगर्स जैसे \textit{Rate}, \textit{Latency}, और \textit{Jitter} का उपयोग करके संचालित होता है, बिना किसी स्थानिक गड़बड़ी के, जिससे स्पाइक वितरण में बदलाव का पता लगाना काफी कठिन हो जाता है। तीन बेंचमार्क न्यूरोमॉर्फिक डेटासेट: N-MNIST, CIFAR10-DVS, और N-Caltech101 पर व्यापक प्रयोगों और सात बेसलाइन बैकडोर रक्षा विधियों के खिलाफ मूल्यांकन के माध्यम से, हम प्रदर्शित करते हैं कि T-Backdoor केवल मामूली सटीकता गिरावट के साथ एकल लक्ष्य और बहु-लक्ष्य दोनों सेटिंग्स में लगभग-पूर्ण 100% हमला सफलता दर (ASR) प्राप्त करता है, जबकि मौजूदा बैकडोर डिटेक्शन और शमन तकनीकों के खिलाफ मजबूत बना रहता है।

रिपॉजिटरी लेआउट

├── models.py                          # Architectures for all datasets (shared)
├── datasets.py                        # Neuromorphic dataset loading (shared)
│
├── main_single.py                     # 1. Single-target entry point
├── single_poisoned_dataset.py         #    Trigger implementations + loaders
├── single_utils.py                    #    Train/eval loop, saving, plots
├── single_target.sh                   #    Paper runs
│
├── main_multi_target.py               # 2. Multi-target entry point
├── multi_target_poisoned_dataset.py   #    Per-target parameter assignment
├── multi_target_utils.py              #    Per-target ASR tracking, saving
├── multi_target.sh                    #    Paper runs
│
├── main_mtmt.py                       # 3. Multi-trigger multi-target entry point
├── mtmt_poisoned_dataset.py           #    Per-target trigger-type config
├── mtmt_utils.py                      #    Per-target ASR tracking, saving
└── mtmt.sh                            #    Paper runs

---

आवश्यकताएँ

• Python 3.11
• CUDA-सक्षम GPU (CPU काम करता है लेकिन अव्यावहारिक रूप से धीमा है)

python -m venv venv
source venv/bin/activate

pip install torch torchvision          # CUDA build matching your driver
pip install spikingjelly
pip install numpy scipy matplotlib seaborn tqdm

रिपोर्ट किए गए परिणामों के लिए उपयोग किया गया संदर्भ वातावरण:

पैकेज	संस्करण
Python	3.11.10
torch	2.11.0+cu128
torchvision	0.26.0+cu128
numpy	2.2.6
scipy	1.16.0
matplotlib	3.8.4
seaborn	0.13.2
spikingjelly	latest from source

डेटासेट सेटअप

कच्चे न्यूरोमॉर्फिक डेटासेट डाउनलोड करें और प्रत्येक को data/ की अपनी उपनिर्देशिका में रखें, जिसका नाम बिल्कुल --dataset मान के अनुसार हो:

data/
├── mnist/       # N-MNIST
├── cifar10/     # CIFAR10-DVS
├── caltech/     # N-Caltech101
└── gesture/     # DVS128-Gesture

⚠️ data/ आपकी कार्यशील निर्देशिका में एक शाब्दिक निर्देशिका होनी चाहिए

उपयोग

1. एकल-लक्ष्य (main_single.py)

एक ट्रिगर, एक लक्ष्य वर्ग।

python main_single.py --dataset cifar10 --type latency --delay_frames 1 \
    --T 10 --epochs 100 --epsilon 0.1 --data_dir 'data/'

मुख्य तर्क

तर्क	डिफ़ॉल्ट	विवरण
--dataset	gesture	mnist, cifar10, caltech, gesture
--type	static	static, moving, smart, latency, rate, jitter, jitter_fixed
--epsilon	0.1	जहर देने के लिए प्रशिक्षण सेट का अंश
--trigger_label	0	लक्ष्य वर्ग
--T	10	सिमुलेशन समय-चरण
--epochs	10	प्रशिक्षण युग
--batch_size	16	बैच आकार
--lr	0.001	सीखने की दर
--loss	mse	mse या cross
--optim	adam	adam या sgd
--amp	बंद	स्वचालित मिश्रित परिशुद्धता सक्षम करें
--seed	42	यादृच्छिक बीज
--data_dir	data/	डेटासेट रूट
--save_path	experiments_single	आउटपुट रूट
--model_path	None	पूर्व-प्रशिक्षित चेकपॉइंट से प्रारंभ करें

ट्रिगर-विशिष्ट तर्क

तर्क	डिफ़ॉल्ट	लागू होता है
--delay_frames	2	latency — विलंब के फ्रेम
--scale_factor	0.5	rate — <1 धीमा, >1 तेज़
--n_shift	3	jitter_fixed — स्वैप किए गए फ्रेम जोड़ों की संख्या
--trigger_size	0.1	static/moving/smart — चौड़ाई के अंश के रूप में पैच आकार
--pos	top-left	static — top-left, top-right, bottom-left, bottom-right, middle, random
--polarity	3	static/moving/smart — 0=काला, 1=गहरा नीला, 2=हरा, 3=हल्का नीला
--n_masks	2	smart — उम्मीदवार क्षेत्रों की संख्या
--least	बंद	smart — सबसे अधिक के बजाय सबसे कम सक्रिय क्षेत्र को लक्षित करें
--most_polarity	बंद	smart — क्षेत्र में सबसे सक्रिय ध्रुवता का उपयोग करें

--epsilon 0.0 सेट करने पर एक स्वच्छ बेसलाइन मॉडल प्रशिक्षित होता है।

---

2. बहु-लक्ष्य (main_multi_target.py)

एक ट्रिगर प्रकार, N लक्ष्य वर्ग जो ट्रिगर के पैरामीटर मान द्वारा अलग किए गए हैं।

# Latency: delay 1 -> class 0, delay 3 -> class 1, delay 5 -> class 2
python main_multi_target.py --dataset mnist --type latency --n_targets 3 \
    --trigger_labels 0 1 2 --delay_params 1 3 5 \
    --epsilon 0.2 --T 10 --epochs 10 --data_dir 'data/'

तर्क	डिफ़ॉल्ट	विवरण
--type	rate	static, latency, rate, jitter, jitter_fixed
--n_targets	3	लक्ष्य वर्गों की संख्या
--trigger_labels	[0..n-1]	स्पष्ट लक्ष्य लेबल; लंबाई --n_targets के बराबर होनी चाहिए
--epsilon	0.1	कुल बजट, लक्ष्यों में समान रूप से विभाजित

प्रति-लक्ष्य पैरामीटर। उन्हें स्पष्ट रूप से दें, या उन्हें एक श्रेणी पर np.linspace द्वारा स्वतः-निर्धारित होने दें। स्पष्ट सूचियों की लंबाई --n_targets होनी चाहिए और वे श्रेणी तर्कों को ओवरराइड करती हैं।

ट्रिगर	स्पष्ट	ऑटो श्रेणी	ऑटो डिफ़ॉल्ट
latency	--delay_params 1 3 5	--delay_min, --delay_max	1 … T//2
rate	--rate_params 0.3 0.6 0.9	--rate_min, --rate_max	0.1 … 6.0
jitter	--jitter_params 0.05 0.15 0.25	--jitter_std_min, --jitter_std_max	0.05 … 0.3
jitter_fixed	--nshift_params 1 3 5	--n_shift_min, --n_shift_max	1 … max(n_shift_min+1, T//4)
static	—	—	T को n_targets फ्रेम समूहों में विभाजित किया गया

स्वतः-निर्धारित पूर्णांक पैरामीटर (latency, jitter_fixed) टकरावों को बढ़ाकर डी-डुप्लिकेट किए जाते हैं, इसलिए कोई भी दो लक्ष्य एक मान साझा नहीं करते।

static के लिए, लक्ष्यों को कौन से फ्रेम पैच ले जाते हैं द्वारा अलग किया जाता है — पैच की उपस्थिति के बजाय समय अक्ष उन्हें अलग करता है।

प्रति-लक्ष्य ASR हर युग में स्वच्छ सटीकता के साथ मुद्रित किया जाता है।

---

3. बहु-ट्रिगर बहु-लक्ष्य (main_mtmt.py)

प्रति लक्ष्य एक अलग ट्रिगर प्रकार।

python main_mtmt.py --dataset mnist --T 10 --n_targets 5 \
    --target_types latency latency rate rate jitter_fixed \
    --trigger_labels 0 1 2 3 4 \
    --latency_delays 1 2 --rate_scales 0.5 2.0 --jitter_fixed_shifts 3 \
    --epsilon 0.3 --epochs 100 --data_dir 'data/'

तर्क	डिफ़ॉल्ट	विवरण
--n_targets	3	लक्ष्यों की संख्या; 3 और 5 में अंतर्निहित प्रीसेट हैं
--target_types	None	प्रति लक्ष्य ट्रिगर प्रकार — static, latency, rate, jitter, jitter_fixed। लंबाई --n_targets के बराबर होनी चाहिए। प्रीसेट को ओवरराइड करता है
--trigger_labels	[0..n-1]	लक्ष्य लेबल
--epsilon	0.2	कुल बजट, लक्ष्यों में समान रूप से विभाजित