You can deploy this model and start earning money today!

Vighneshkumbhar/
intercept-prediction-mlp

Name: intercept-prediction-mlp
Availability: InStock

Views

No views yet

🎯 Intercept Prediction MLP

A neural network model that predicts the optimal intercept point (x, y) for a missile targeting a moving aircraft in a 2D simulation. Designed for real-time guidance systems with sub-millisecond inference.

📊 Performance

Metric	Value	Target	Status
Mean Distance Error	100.04 units	< 120	✅ PASS
Max Distance Error	599.45 units	< 600	✅ PASS
Median Error	76.15 units	—	—
R² Score (overall)	0.99987	—	—
R² Score (IX)	0.99986	—	—
R² Score (IY)	0.99987	—	—
90th Percentile Error	207.0 units	—	—
95th Percentile Error	249.8 units	—	—
Inference Speed	0.6 ms / prediction	Real-time	✅

🧠 Model Architecture

InterceptPredictor (444,860 parameters)
├── Network (Sequential)
│   ├── Linear(28 → 512) + BatchNorm + ReLU + Dropout(0.05)
│   ├── Linear(512 → 512) + BatchNorm + ReLU + Dropout(0.05)
│   ├── Linear(512 → 256) + BatchNorm + ReLU + Dropout(0.05)
│   ├── Linear(256 → 128) + BatchNorm + ReLU + Dropout(0.05)
│   └── Linear(128 → 2)
└── Skip Connection: Linear(28 → 2)

Key design choices:

Skip connection allows the model to learn residuals on top of a linear baseline
BatchNorm for training stability
Low dropout (5%) to preserve capacity while preventing overfitting
Physics-inspired feature engineering (28 features from 7 raw inputs)

📥 Input Features

Feature	Description	Range
R	Distance to target	500–15,000 units
LOS	Line-of-sight angle	-π to π rad
Vc	Closing velocity	50–800 units/s
Target_H	Target heading	-π to π rad
Missile_H	Missile heading	-π to π rad
Aspect	Relative orientation	-π to π rad
Tgo_Input	Time-to-go	1–30 seconds

📤 Outputs

Output	Description
Label_IX	Intercept X coordinate
Label_IY	Intercept Y coordinate

🚀 Quick Start

python

import torch
import torch.nn as nn
import joblib
import numpy as np

# Load model
class InterceptPredictorModel(nn.Module):
    def __init__(self, input_dim=28, hidden_dims=[512, 512, 256, 128], dropout=0.05):
        super().__init__()
        layers = []
        prev_dim = input_dim
        for h_dim in hidden_dims:
            layers.extend([nn.Linear(prev_dim, h_dim), nn.BatchNorm1d(h_dim), nn.ReLU(), nn.Dropout(dropout)])
            prev_dim = h_dim
        layers.append(nn.Linear(prev_dim, 2))
        self.network = nn.Sequential(*layers)
        self.skip = nn.Linear(input_dim, 2)
    def forward(self, x):
        return self.network(x) + self.skip(x)

checkpoint = torch.load('intercept_model_full.pth', map_location='cpu', weights_only=True)
model = InterceptPredictorModel()
model.load_state_dict(checkpoint['model_state_dict'])
model.eval()

scaler_X = joblib.load('scaler_X.pkl')
scaler_y = joblib.load('scaler_y.pkl')

# Predict (see inference.py for the full feature engineering pipeline)

Or use the provided inference script:

python

from inference import InterceptPredictor

predictor = InterceptPredictor()
result = predictor.predict_single(
    R=8000, LOS=0.5, Vc=400, Target_H=1.2,
    Missile_H=0.8, Aspect=0.3, Tgo_Input=15
)
print(f"Intercept: ({result['IX']:.1f}, {result['IY']:.1f})")

🔧 Feature Engineering

28 features are derived from 7 raw inputs:

Raw features (7): R, LOS, Vc, Target_H, Missile_H, Aspect, Tgo_Input
Trigonometric (8): cos/sin of LOS, Target_H, Missile_H, Aspect
Position (2): R·cos(LOS), R·sin(LOS)
Velocity (3): effective speed, target_vx, target_vy
Displacement (2): velocity × Tgo
Direct estimates (2): position + displacement
Interactions (4): Vc·Tgo, R·Tgo, Vc·cos(TH), Vc·sin(TH)

📁 Files

File	Description
`intercept_model_full.pth`	Full PyTorch checkpoint (weights + metadata)
`intercept_model_traced.pt`	TorchScript model for deployment
`scaler_X.pkl`	Input StandardScaler
`scaler_y.pkl`	Output StandardScaler
`inference.py`	Complete inference pipeline with feature engineering
`metrics.json`	Evaluation metrics
`feature_config.json`	Feature engineering configuration
`evaluation_plots.png`	6-panel evaluation dashboard
`residual_plots.png`	Residual analysis plots
`intercept_dataset.csv`	Training dataset (4000 samples)

📈 Training Details

Dataset: 4,000 synthetic physics-based samples (80/20 train/test split)
Optimizer: AdamW (lr=5e-4, weight_decay=1e-4)
Scheduler: CosineAnnealingWarmRestarts (T_0=50, T_mult=2)
Loss: MSE on StandardScaler-normalized outputs
Early Stopping: patience=40, best epoch=130/170
Training Time: ~112 seconds on CPU

⚠️ Deployment Notes

Model runs entirely on CPU with sub-millisecond inference
For receding horizon systems: instantiate InterceptPredictor once, call .predict() or .predict_single() repeatedly
TorchScript model (intercept_model_traced.pt) can be loaded in C++ for embedded deployment
All input features must be preprocessed through the same feature engineering + scaling pipeline

Vighneshkumbhar/intercept-prediction-mlp