Datasets:

bukac82
/

MicroDopplerSignatures

The number of columns (1007) exceeds the maximum supported number of columns (1000). This is a current limitation of the datasets viewer. You can reduce the number of columns if you want the viewer to work.

Error code:   TooManyColumnsError

Need help to make the dataset viewer work? Make sure to review how to configure the dataset viewer, and open a discussion for direct support.

🛰️ What Is This?

Radar Micro-Doppler AI is a research-grade, end-to-end pipeline for classifying helicopter and multi-rotor drone types from their micro-Doppler radar signatures — the unique frequency modulation pattern created by rotating rotor blades.

The repository brings together three paradigms of AI on a single, unified dataset:

Paradigm	Methods	Input
Classical ML	SVM · Random Forest · XGBoost · k-NN	14 hand-crafted physics features
Quantum ML	Quantum Kernel SVM · VQC (PennyLane)	4-D PCA → angle embedding
Deep Learning	ResNet CNN · Bi-LSTM · Spectrogram Transformer	STFT spectrograms / raw IQ

Plus:

🔒 Robustness Testing — SNR sweeps (−5 to 30 dB), FGSM & PGD adversarial attacks
🔍 Open-Set Recognition — Energy-based OOD detection for unknown aerial targets
💡 Explainability — SHAP feature importance + Grad-CAM heatmaps

📊 Benchmark Results

Results on the held-out test set (20% of 5,000 samples), SNR ∈ [5, 25] dB.

Model	Accuracy	Macro-F1	ROC-AUC
SVM (RBF, C=10)	0.9620	0.9619	0.9971
Random Forest (n=200)	0.9780	0.9780	0.9994
XGBoost	0.9740	0.9739	0.9991
k-NN (k=7)	0.9480	0.9479	0.9940
CNN (ResNet-style)	0.9870	0.9870	0.9998
Bi-LSTM	0.9810	0.9810	0.9996
Spectrogram Transformer	0.9830	0.9829	0.9997
Quantum Kernel SVM (4q)	0.8200	0.8192	0.9421
VQC (4q, 2 layers)	0.7867	0.7851	0.9108

Key insight: The blade flash rate (n_blades × RPM / 60) is the single most discriminative feature, directly readable from the STFT spectrogram as periodic vertical striations.

🎯 Target Classes

🚁 Helicopters

Class	Helicopter	Blades	RPM	Blade Radius
2-blade	Bell UH-1 (Huey)	2	300–350	6.5–7.5 m
3-blade	Aérospatiale Gazelle	3	360–400	4.5–5.5 m
4-blade	Apache AH-64 / UH-60 Black Hawk	4	250–300	7.0–8.5 m

🛸 Drones (UAVs)

Class	Type	Rotors	Blades/Rotor	RPM	Blade Radius	Reference
quadcopter	Quadcopter	4	2	4,000–8,000	7.5–12.5 cm	DJI Phantom / Mavic
hexacopter	Hexacopter	6	2	2,000–4,000	20–35 cm	DJI Matrice 600
octocopter	Octocopter	8	2	1,500–3,000	25–45 cm	DJI S1000

🗂️ Project Structure

radar-microdoppler-ai/
│
├── 📓 notebooks/
│   ├── 01_EDA_and_Signal_Analysis.ipynb
│   ├── 02_Classical_ML_Benchmark.ipynb
│   ├── 03_Deep_Learning.ipynb
│   └── 04_Quantum_ML.ipynb
│
├── 📡 Dataset/                  ← Data generation & loading
├── 🔧 Preprocessing/            ← STFT spectrograms, feature extraction
├── 🤖 Classical_ML/             ← SVM, RF, XGBoost, k-NN
├── ⚛️  Quantum_ML/              ← QK-SVM, VQC (PennyLane)
├── 🧠 Deep_Learning/            ← CNN, LSTM, Transformer (PyTorch)
├── 🛡️  Robustness_Testing/      ← SNR sweep, FGSM/PGD attacks
├── 🔓 Open_Set_Recognition/     ← Energy OOD, AUROC/OSCR metrics
├── 💡 Explainability/           ← SHAP, Grad-CAM
├── 📈 Evaluation/               ← Unified benchmark & metrics
│
├── 🧪 tests/                    ← Pytest unit tests
├── 📜 scripts/
│   ├── download_data.py         ← Dataset download / local generation
│   └── run_full_pipeline.py     ← End-to-end pipeline runner
│
├── pyproject.toml
├── requirements.txt
└── CITATION.cff

⚡ Quick Start

1. Install

git clone https://github.com/bukac82/radar-microdoppler-ai.git
cd radar-microdoppler-ai

pip install -e ".[all]"          # everything: DL + QML + explainability
# or
pip install -e ".[dl]"           # PyTorch only
pip install -e ".[qml]"          # PennyLane only

2. Download the Dataset

# Option A — HuggingFace Hub (recommended, ~8 GB total for all 4 datasets)
pip install huggingface-hub
python scripts/download_data.py

# Option B — Direct CLI
huggingface-cli download bukac82/MicroDopplerSignatures \
    --repo-type dataset --local-dir .

# Option C — Generate locally
python scripts/download_data.py --source generate

3. Run the Full Pipeline

python scripts/run_full_pipeline.py --nrows 5000

4. Explore Notebooks

jupyter notebook notebooks/

📓 Notebooks

#	Notebook	Description
01	EDA & Signal Analysis	Dataset statistics, IQ signals, spectrograms, feature correlation
02	Classical ML Benchmark	SVM / RF / k-NN training, confusion matrices, SHAP, SNR sweep
03	Deep Learning	CNN/LSTM/Transformer training curves, Grad-CAM visualization
04	Quantum ML	QK-SVM & VQC on 4-D PCA features, Classical vs Quantum comparison

🔬 Dataset

🤗 bukac82/MicroDopplerSignatures — publicly available on HuggingFace Hub

Two physics-accurate synthetic datasets generated from the sinc-based micro-Doppler model:

Dataset	Samples	Features	Size
Base (`helicopter_microdoppler_dataset.csv`)	100,000	IQ @ 1 kHz, 0.5s window	~2 GB
Extended (`helicopter_microdoppler_extended_dataset.csv`)	100,000	+ varied radar freq (8–12 GHz), elevation (0–45°), bulk velocity (±50 m/s)	~2 GB

Signal model (Doppler from rotating blade):

$s_k(t) = L \cdot \text{sinc}\!\left(\frac{2L}{\lambda}\cos\phi_k\cos\beta\right) \exp\!\left(j\frac{4\pi L}{\lambda}\cos\phi_k\cos\beta\right)$

where $\phi_k = \omega t + \theta_0 + \frac{2\pi k}{N_b}$ is the phase of the $k$-th blade, $L$ is the blade length, $\lambda$ is the radar wavelength, and $\beta$ is the elevation angle.

# Load directly in Python via HuggingFace datasets library
from datasets import load_dataset

ds = load_dataset("bukac82/MicroDopplerSignatures", split="train")

🏗️ Architecture Overview

                        ┌──────────────────────────────────────────┐
                        │           Raw IQ Signal (500 × complex)  │
                        └─────────────────┬────────────────────────┘
                                          │
              ┌───────────────────────────┼────────────────────────────┐
              ▼                           ▼                            ▼
    ┌──────────────────┐      ┌────────────────────┐      ┌──────────────────────┐
    │  Feature Extract │      │  STFT Spectrogram  │      │  Raw IQ (I,Q) → (T,2)│
    │  (14-D vector)   │      │  (33 × 15 image)   │      │  for LSTM            │
    └────────┬─────────┘      └────────┬───────────┘      └──────────┬───────────┘
             │                         │                              │
    ┌────────▼────────┐      ┌─────────▼──────────┐      ┌──────────▼───────────┐
    │ Classical ML    │      │  CNN / Transformer  │      │   Bi-LSTM            │
    │ SVM · RF · kNN  │      │  (Deep Learning)    │      │   (128 hidden)       │
    └────────┬────────┘      └─────────┬──────────┘      └──────────┬───────────┘
             │                         │                              │
             └────────────────┬────────┘──────────────────────────────┘
                              ▼
                    ┌──────────────────┐
                    │  Evaluation      │
                    │  Robustness Test │
                    │  OSR Detection   │
                    │  Explainability  │
                    └──────────────────┘

⚛️ Quantum ML

The quantum pipeline reduces features to 4 dimensions via PCA, then:

QK-SVM: Encodes features into quantum states via angle embedding; kernel computed as fidelity |⟨φ(x)|φ(x')⟩|²
VQC: Parameterized StronglyEntanglingLayers trained with Adam optimizer and cross-entropy loss

from Quantum_ML.qkernel_svm import QuantumKernelSVM

qksvm = QuantumKernelSVM(n_qubits=4, C=1.0)
qksvm.fit(X_train_scaled, y_train)
print(f"Quantum Kernel SVM accuracy: {qksvm.score(X_test_scaled, y_test):.4f}")

🛡️ Robustness Testing

from Robustness_Testing.noise_robustness import snr_sweep

# Sweep from -5 dB to 30 dB
results = snr_sweep(predict_fn, X_iq_test, y_test, snr_range=range(-5, 31, 5))
# {-5: 0.61, 0: 0.79, 5: 0.91, 10: 0.97, 15: 0.98, ...}

from Robustness_Testing.adversarial import evaluate_adversarial

# FGSM attack at varying epsilon
adv_results = evaluate_adversarial(cnn_model, X_test, y_test,
                                    epsilon_values=[0.001, 0.01, 0.05])

💡 Explainability

SHAP (Classical ML):

from Explainability.shap_explainer import explain_with_shap, plot_shap_summary
shap_values = explain_with_shap(rf_model, X_train, X_test, model_type="tree")
plot_shap_summary(shap_values, X_test, model_name="random_forest")

Grad-CAM (CNN):

from Explainability.gradcam import GradCAM
cam = GradCAM(cnn_model, target_layer=cnn_model.layer3)
heatmap = cam(spectrogram_tensor, class_idx=1)  # highlights 3-blade freq bands

🔓 Open-Set Recognition

Detects unknown aerial targets (drones, birds) not seen during training:

from Open_Set_Recognition.energy_ood import EnergyOODDetector
from Open_Set_Recognition.evaluate_osr import print_osr_report

detector = EnergyOODDetector(cnn_model, threshold=-25.0)
is_unknown = detector.predict(X_unknown)   # True = reject as unknown

print_osr_report(id_energy_scores, ood_energy_scores)
# AUROC: 0.934  |  FPR@95TPR: 0.127

🤝 Contributing

Contributions welcome! See CONTRIBUTING.md for guidelines.

Ideas for contribution:

🚁 Add new helicopter classes (Chinook CH-47, V-22 Osprey)
🐦 Add drone / bird / UAV signatures for open-set testing
📡 Add Ka-band / W-band radar parameters
🔬 Implement Integrated Gradients or LIME explainability
⚛️ Implement Quantum Neural Networks with larger qubit counts

📖 Citation

If you use this project or dataset in your research, please cite the software repository and/or the relevant papers below:

Software Repository

@software{agnihotri2026microdoppler,
  author    = {Agnihotri, Vikas},
  title     = {Radar Micro-Doppler AI: End-to-End Helicopter Classification
               with Classical, Quantum, and Deep Learning},
  year      = {2026},
  url       = {https://github.com/bukac82/radar-microdoppler-ai},
  license   = {MIT}
}

Related Papers

This repository builds upon the following peer-reviewed publications by the author:

Quantum ML on NISQ Hardware (most relevant to the Quantum_ML/ module):

@article{agnihotri2026quantum,
  author    = {Agnihotri, Vikas and Kaur, Jasleen and Kaushik, Sarvagya},
  title     = {Practical Evaluation of Quantum Kernel Methods for Radar
               Micro-Doppler Classification on Noisy Intermediate-Scale
               Quantum ({NISQ}) Hardware},
  journal   = {arXiv preprint},
  volume    = {arXiv:2601.22194},
  year      = {2026},
  url       = {https://arxiv.org/abs/2601.22194}
}

Radar-Based ATR Framework (foundational signal model and SVM classifier):

@article{agnihotri2020radar,
  author    = {Agnihotri, Vikas and Sabharwal, Munish},
  title     = {An Automatic Radar Based Aerial Target Recognition Framework},
  journal   = {Journal of Interdisciplinary Mathematics},
  volume    = {23},
  number    = {2},
  pages     = {321--333},
  year      = {2020},
  doi       = {10.1080/09720502.2020.1737377},
  url       = {https://doi.org/10.1080/09720502.2020.1737377}
}

Frequency Effects on Micro-Doppler (radar frequency analysis underpinning the extended dataset):

@inproceedings{agnihotri2019frequency,
  author    = {Agnihotri, Vikas and Sabharwal, Munish and Goyal, Vinay},
  title     = {Effect of Frequency on Micro-Doppler Signatures of a Helicopter},
  booktitle = {2019 International Conference on Advances in Big Data,
               Computing and Data Communication Systems (icABCD)},
  year      = {2019},
  doi       = {10.1109/ICABCD.2019.8851024},
  url       = {https://doi.org/10.1109/ICABCD.2019.8851024}
}

📚 References

Author's Publications

Agnihotri, V., Kaur, J., & Kaushik, S. (2026). Practical Evaluation of Quantum Kernel Methods for Radar Micro-Doppler Classification on NISQ Hardware. arXiv:2601.22194
Agnihotri, V., & Sabharwal, M. (2020). An automatic radar based aerial target recognition framework. Journal of Interdisciplinary Mathematics, 23(2), 321–333. DOI: 10.1080/09720502.2020.1737377
Agnihotri, V., Sabharwal, M., & Goyal, V. (2019). Effect of frequency on micro-Doppler signatures of a helicopter. 2019 International Conference on Advances in Big Data, Computing and Data Communication Systems (icABCD). DOI: 10.1109/ICABCD.2019.8851024

Background Literature

Chen, V.C., Li, F., Ho, S.S., & Wechsler, H. (2006). Micro-Doppler effect in radar: phenomenon, model, and simulation study. IEEE TAS.
Molchanov, P., et al. (2015). Classification of small UAVs and birds by micro-Doppler signatures. IET Radar.
Bendale, A., & Boult, T.E. (2016). Towards open set deep networks (OpenMax). CVPR.
Liu, W., et al. (2020). Energy-based out-of-distribution detection. NeurIPS.
Schuld, M., & Petruccione, F. (2021). Machine Learning with Quantum Computers. Springer.

_{Made with ❤️ for the radar signal processing and AI community}

Downloads last month: 149

Total file size:

8.51 GB

Paper for bukac82/MicroDopplerSignatures

Practical Evaluation of Quantum Kernel Methods for Radar Micro-Doppler Classification on Noisy Intermediate-Scale Quantum (NISQ) Hardware

Paper • 2601.22194 • Published Jan 29