ATAS is an end to end ML threat assessment pipeline that identifies aircraft from images, simulates engagement scenarios, predicts evasion survivability, and generates cockpit style tactical recommendations.
Live Demo on Hugging Face Spaces
Aircraft Image
↓
[1] EfficientNetV2 L Aircraft Classifier
↓
[2] Aircraft Metadata Lookup
↓
[3] Physics Based Scenario Generation
↓
┌───────────────────────────────────────┐
↓ ↓
[4] ETA Regressor [5] Hit Classifier
↓ ↓
└────────── Threat Assessment ──────────┘
↓
[6] Tactical Decision Layer
↓
[7] FastAPI Backend + HUD
ATAS was inspired by fighter jet Radar Warning Receiver systems where pilots need fast threat interpretation under incomplete information.
The project combines computer vision, physics simulation, structured ML, and tactical logic into a single end to end inference pipeline.
It is not a real military system and does not attempt to simulate classified avionics behavior. The goal was building a complete end to end ML system where an aircraft image becomes a tactical recommendation through multiple independent subsystems working together.
One of the biggest inspirations behind ATAS was the F-35 Distributed Aperture System (DAS).
DAS is a real world sensor fusion system that combines infrared cameras around the aircraft to give the pilot full spherical threat awareness and automatic warning cues directly inside the cockpit.
ATAS is obviously not attempting to recreate that system. The scale and complexity are completely different.
What fascinated me was the idea of multiple independent subsystems working together to help a pilot interpret a threat quickly under pressure. That became the core design idea behind this project.
Idle state |
Target acquired |
Safe state (C 130, green) |
Critical threat (Su 57 vs F 22, red) |
| Category | Technology |
|---|---|
| Deep Learning | TensorFlow, EfficientNetV2 L |
| Structured ML | XGBoost, scikit learn |
| Hyperparameter Tuning | Optuna |
| Backend | FastAPI, uvicorn |
| Frontend | HTML, CSS, JavaScript |
| Containerization | Docker |
| Deployment | Hugging Face Spaces |
| Data Processing | pandas, numpy |
| Version Control | Git, GitHub, Git LFS |
| Model | Algorithm | Key Metric | Score |
|---|---|---|---|
| Aircraft Classifier | EfficientNetV2 L | Top 1 Accuracy | 78.08% |
| Aircraft Classifier | EfficientNetV2 L | Top 5 Accuracy | 92.02% |
| ETA Regressor | XGBoost Regressor | R² | 0.9939 |
| ETA Regressor | XGBoost Regressor | MAE | 0.4552 seconds |
| Hit Classifier | XGBoost Classifier | Recall | 0.9966 |
| Hit Classifier | XGBoost Classifier | ROC AUC | 0.9999 |
The classifier supports 101 military aircraft classes including fighters, bombers, transport aircraft, helicopters, UAVs, and experimental platforms across multiple generations.
Examples include:
F22, F35, Su57, Rafale, J20, Mig29, B2, SR71, Tejas, KAAN, MQ9, AH64, C17, Tu160
Full 101 aircraft class list
A10, A400M, AG600, AH64, AKINCI, AV8B, An124, An22, An225, An72, B1, B2, B21, B52, Be200, C1, C130, C17, C2, C390, C5, CH47, CH53, CL415, E2, E7, EF2000, EMB314, F117, F14, F15, F16, F18, F2, F22, F35, F4, FCK1, H6, Il76, J10, J20, J35, J36, J50, JAS39, JF17, JH7, KAAN, KC135, KF21, KIZILELMA, KJ600, Ka27, Ka52, MQ20, MQ25, MQ28, MQ9, Mi24, Mi26, Mi28, Mi8, Mig29, Mig31, Mirage2000, NH90, P3, RQ4, Rafale, SR71, Su24, Su25, Su34, Su47, Su57, T50, TB001, TB2, Tejas, Tornado, Tu160, Tu22M, Tu95, U2, UH60, US2, V22, V280, Vulcan, WZ10, WZ7, WZ9, X29, X32, XB70, XQ58, Y20, YF23, Z10, Z19, Z21
Physics equations require complete and clean inputs. Real inference environments rarely provide that.
The physics generator creates structured ground truth engagement data. The ML models learn the non linear patterns from those scenarios and later generalize from partial inputs during inference.
The ETA regressor predicts when the pilot needs to react.
The hit classifier predicts whether evasion is likely to succeed.
Neither answer is useful alone. Together they answer the actual cockpit question:
Do I have enough time and will evasion work?
XGBoost consistently produced the best MAE across all tested regressors.
It also provided:
- GPU accelerated Optuna tuning
- Large hyperparameter search space
- Stable inference behavior
- SHAP explainability support
The final Optuna search stopped around 944 trials once validation MAE improvements became marginal.
The tactical recommendation layer is intentionally deterministic in V1.
This keeps the system:
- Explainable
- Easy to debug
- Easy to validate
- Fast to iterate on
A natural V2 upgrade would be replacing this layer with a reinforcement learning policy agent.
The final EfficientNetV2 L classifier model is approximately 898MB.
That exceeds practical GitHub LFS usage limits, so the production weights are hosted separately on Hugging Face instead.
This became a real deployment constraint during the project rather than a theoretical architecture choice.
ATAS was intentionally built in a modular way so different parts of the system can improve independently.
Some possible upgrade paths:
- Real radar or telemetry inputs instead of synthetic scenarios
- Reinforcement learning based tactical decision system
- Video based tracking instead of single image inference
- Multi target threat prioritization
- Live streaming inference
- Multi sensor fusion instead of image only input
- More interactive HUD controls
The current system is intentionally focused on proving the full end-to-end pipeline first before increasing realism and complexity.
ATAS_Project/
├── app/
│ ├── main.py
│ ├── test_pipeline.py
│ └── README.md
│
├── src/
│ ├── classifier.py
│ ├── metadata.py
│ ├── physics_generator.py
│ ├── models.py
│ ├── decision.py
│ ├── schemas.py
│ ├── analysis_for_physics_generator.ipynb
│ └── README.md
│
├── notebooks/
│ ├── 01_aircraft_classifier_v1.ipynb
│ ├── 02_aircraft_classifier_v2.ipynb
│ ├── 02_eta_regressor.ipynb
│ ├── 03_hit_classifier.ipynb
│ └── README.md
│
├── frontend/
│ └── atas_hud_v11.html
│
├── release_models/
│ ├── aircraft_classifier/
│ ├── eta/
│ └── hit/
│
├── assets/
│ └── demonstration/
│
├── data/
│ └── aircraft_metadata.csv
│
├── Dockerfile
├── requirements.txt
└── README.md
git clone https://github.com/Eakempreet/ATAS_Project.gitcd ATAS_Projectdocker build -t atas .docker run -p 7860:7860 atasOpen:
http://localhost:7860
pip install -r requirements.txtuvicorn app.main:app --host 0.0.0.0 --port 8000Open:
http://localhost:8000
| Resource | Link |
|---|---|
| Dataset | https://kaggle.com/datasets/a2015003713/militaryaircraftdetectiondataset |
| Live Demo | https://huggingface.co/spaces/Eakempreet/ATAS |
| Model Weights Backup | https://huggingface.co/Eakempreet/ATAS-models |
| GitHub Repository | https://github.com/Eakempreet/ATAS_Project |
| Folder | README | What it covers |
|---|---|---|
notebooks/ |
notebooks/README.md |
Model training pipelines and experiments |
src/ |
src/README.md |
Core inference modules and data flow |
app/ |
app/README.md |
FastAPI backend and API endpoints |