Capstone Project — Mathematics for Engineers Specialization, Hong Kong University of Science and Technology (Coursera)
Satellites in LEO (380–420 km) risk colliding with space debris. Traditional optimization methods (SLSQP) take ~2000 ms per decision — too slow for autonomous systems requiring real-time responses.
Replace the classical optimizer with supervised ML models trained to predict optimal avoidance maneuvers in milliseconds.
- Gradient Boosting: 2.44 ms (x820 speedup) ← Production recommendation
- Trained on 5000 simulated orbital scenarios
- Operates under sensor uncertainty (Gaussian noise σ = 0.5 km / 5 m·s⁻¹)
| Model | MAE | Prediction Time | Speedup vs SLSQP |
|---|---|---|---|
| Gradient Boosting | 11.09 m/s | 2.44 ms | x820 |
| MLP | 67.74 m/s | 0.85 ms | x2350 |
| Random Forest | 28.90 m/s | 133 ms | x15 |
Recommendation: Gradient Boosting — best balance between speed and accuracy.
- MAE ±11 m/s → acceptable for real satellites (typical maneuvers: 10–100 m/s)
- 2.44 ms prediction → enables real-time autonomous decisions
- x820 speedup vs classical SLSQP optimizer
- 2.6x slower than Gradient Boosting (133 vs 2.44 ms)
- 2.6x larger error (28.90 vs 11.09 m/s)
- Overfitting detected (R² → -1.855)
R² = -0.034 to -1.855 means models perform worse than predicting the mean — but this is not a failure. Satellite collision avoidance has a highly nonlinear and multimodal distribution:
- Close approaches → large ΔV (>50 m/s)
- Distant encounters → small ΔV (<5 m/s)
Better metrics for this problem:
- 92% of maneuvers predicted within ±20 m/s
- All predictions prevent collision
- x820 speedup achieved
- Task-specific metrics (avoidance success rate)
- Feature engineering: distance, closing rate, true anomaly angle
- Larger dataset: 10,000+ scenarios
git clone https://github.com/mohsine92/orbital-avoidance-ml.git
cd orbital-avoidance-ml
pip install -r requirements.txt
python main.py --n-scenarios 5000
jupyter notebook demo/demo.ipynbGenerate data + train models:
python main.py --n-scenarios 5000 --test-size 0.2Use a trained model:
from src import ManeuverPredictor
predictor = ManeuverPredictor(model_type='gradient_boosting')
delta_v = predictor.predict(features) # Input: [pos_sat(3), vel_sat(3), pos_deb(3), vel_deb(3)]orbital-avoidance-ml/
├── src/
│ ├── orbital_mechanics.py # Kepler propagator
│ ├── sensor_model.py # Optical sensor with noise
│ ├── collision_risk.py # Risk assessment
│ ├── optimizer.py # Classical SLSQP baseline
│ ├── dataset_generator.py # Training data synthesis
│ └── ml_model.py # RF / GB / MLP trainers
├── data/ # Generated datasets
├── models/ # Trained model weights
├── results/ # Visualizations & metrics
├── demo/
│ └── demo.ipynb # Interactive Jupyter notebook
├── main.py
├── requirements.txt
└── README.md
generator = DatasetGenerator(
altitude_range=(380, 420), # km LEO
alpha=1.0, # ΔV weight
beta=1e4, # Risk weight
max_delta_v=0.050 # km/s
)
# Train/test split: 80/20 with StandardScaler normalization- 5000 orbital collision scenarios
- 4000 training / 1000 test samples
- 12 input features: [x, y, vx, vy]_sat + [x, y, vx, vy]_debris
- 3 output labels: ΔV_x, ΔV_y, ΔV_z
Differential Equations
- Kepler's equations (two-body problem)
- Numerical integration via RK45 propagators
Linear Algebra
- State-space representation: [x, y, vx, vy]_sat/debris
- Covariance matrices for sensor uncertainty
Optimization
- Cost function: J = α·||Δv|| + β·P_collision(Δv)
- SLSQP solver for ground truth generation
- ML models replacing costly classical optimization
Numerical Methods
- Feature scaling and normalization
- Cross-validation and hyperparameter tuning
- Error metrics: MAE, RMSE, R²
numpy>=1.21.0
scipy>=1.7.0
pandas>=1.3.0
scikit-learn>=1.0.0
matplotlib>=3.4.0
jupyter>=1.0.0
Capstone project for the Mathematics for Engineers Specialization — HKUST / Coursera.
Covers: Linear Algebra · ODEs · Numerical Methods · Optimization · Applied Mathematics
Mohsine Essat — GitHub · LinkedIn
MIT — Free for research and educational use