🌌 Exoplanet Detection ML System

A production-ready machine learning platform that transforms how we identify exoplanets by automatically analyzing data from NASA's space telescopes. Built for the NASA Space Apps Challenge 2025, this system makes exoplanet discovery faster, more accurate, and accessible to everyone from professional astronomers to citizen scientists.

Imagine trying to find a grain of sand on a beach by looking at millions of photographs. That's what finding exoplanets is like. NASA's telescopes (Kepler, K2, and TESS) capture millions of observations of stars, and somewhere in that data are signals from planets passing in front of their host stars. Currently, humans have to manually review each potential planet candidate, which takes weeks or months per object. With thousands of candidates waiting to be analyzed, we're creating a bottleneck that slows down discovery.

• Kepler observed 150,000 stars over 4 years, producing 2,662 confirmed planets

• K2 extended this with 500,000+ target stars across different sky regions

• TESS currently monitors 200,000 stars, generating 27 million measurements daily

70-80% of detected signals are "false positives" (mimicking planetary transits but actually being eclipsing binary stars, instrumental noise, or stellar activity).

Manual classification by expert astrophysicists is time-intensive, with each candidate requiring careful analysis of:

• Orbital parameters (period, duration, depth)

• Star properties (temperature, radius, brightness)

• Statistical significance (signal-to-noise ratios)

• Follow-up observation feasibility

• Discovery Speed: Automated classification reduces analysis time from weeks to milliseconds

• Hidden Discoveries: Thousands of Kepler candidates remain unconfirmed in archives

• Resource Allocation: False positive filtering prevents wasting expensive telescope time on follow-up observations

• Habitability Search: Faster triage means we identify Earth-like exoplanets in habitable zones sooner

Most exoplanet tools only work with one telescope's data. We built a translator that combines data from three different NASA missions (Kepler, K2, TESS), each with different formats and labeling systems. Think of it like having a universal translator that reads data from American, European, and Asian space agencies seamlessly.

We implement intelligent disposition mapping across missions:

• Kepler: Maps koi_pdisposition field (CONFIRMED, CANDIDATE, FALSE POSITIVE)

• TESS: Harmonizes tfopwg_disp labels (CP, PC, APC, FP, KP categories)

• K2: Translates k2c_disp classifications

Our unified schema merges 13,735+ labeled samples into three classes (confirmed, candidate, false_positive), resolving edge cases like TESS's "Ambiguous Planetary Candidate" (APC) classification.

Most AI is a "black box" - it gives an answer but doesn't explain why. Our system shows exactly which measurements (transit depth, orbital period, etc.) contributed most to each decision. If it says "this is a planet," scientists can see that it was because of deep transits, consistent timing, and strong signal - not a lucky guess.

We use SHAP (SHapley Additive exPlanations) TreeExplainer to compute Shapley values for each prediction:

• Per-sample explanations: Each prediction includes top-5 feature attributions with signed SHAP values

• Global importance: Feature importance rankings validate alignment with astrophysical priors (e.g., transit depth = 23.4% importance)

• Waterfall plots: Visual breakdown shows how each feature pushed probability toward final class

• Scientific validation: Astronomers can verify model reasoning against known physics

• Debugging: Identifies when model relies on spurious correlations

• Trust: Published research requires explainable methodology for peer review acceptance

Raw telescope data doesn't capture relationships between measurements. We create new "super features" by combining basic measurements in smart ways. For example, dividing a planet's orbital period by its transit duration reveals information about the planet's orbit geometry - something that's obvious to an astronomer but hidden from standard machine learning.

Our feature engineering pipeline derives 47 features from raw NASA columns:

• Log Transformations: log(period), log(radius), log(duration)

Why: Exoplanet distributions are log-normal (Jupiter-sized to Earth-sized = 4 orders of magnitude)

Impact: Linearizes skewed distributions for better ML performance

Geometric Ratios:

period / duration → Reveals orbital inclination angle

planet_radius² → Proportional to transit area (physical blocking)

depth × duration → Total signal energy proxy

• estimated_snr = sqrt(|depth|) → Noise-to-signal confidence (Derived for datasets missing native SNR columns)

• Planet-to-star radius ratios

• Impact parameter adjustments for grazing transits

Imagine training a detector to find rare golden tickets when 80% of your training examples are regular tickets. The detector would just say "regular ticket" every time and be 80% accurate while missing all golden tickets. We use a technique called SMOTE to create synthetic "golden ticket" examples during training so the model learns to recognize them properly.

Our pipeline implements SMOTE (Synthetic Minority Over-sampling Technique) with rigorous leakage prevention:

# SMOTE ONLY inside cross-validation training folds
for train_idx, val_idx in cv.split(X, y):
    X_train, y_train = X[train_idx], y[train_idx]
    X_train_res, y_train_res = smote.fit_resample(X_train, y_train)  # ✓ Safe
    model.fit(X_train_res, y_train_res)
    # Validation on ORIGINAL (non-oversampled) data
    score = model.score(X[val_idx], y[val_idx])  # ✓ No leakage

Original: ~60% false positive, ~30% candidate, ~10% confirmed

After SMOTE: 33% / 33% / 33% (balanced training)

Most AI research ends with a Jupyter notebook that only the creator can run. We built a complete system with a web interface, API for automated use, testing, and one-command deployment. It's the difference between a prototype car and a production vehicle with safety features, user manual, and warranty.

┌─────────────────────────────────────────────────────────────┐
│                    USER INTERFACES                          │
├─────────────────────┬───────────────────────────────────────┤
│  Streamlit Web UI   │       FastAPI REST API                │
│  - Manual entry     │       - /predict (single)             │
│  - Batch upload     │       - /predict_batch (CSV)          │
│  - Retraining       │       - /model/metrics                │
│  - Visualizations   │       - /model/features               │
└──────────┬──────────┴────────────┬──────────────────────────┘
           │                       │
           └───────────┬───────────┘
                       ▼
           ┌───────────────────────┐
           │   INFERENCE LAYER     │
           │   - ExoplanetModel    │
           │   - SHAP Explainer    │
           └───────────┬───────────┘
                       ▼
           ┌───────────────────────┐
           │  PREPROCESSING        │
           │  - Imputation         │
           │  - Scaling            │
           │  - Feature Eng        │
           └───────────┬───────────┘
                       ▼
           ┌───────────────────────┐
           │   TRAINED MODEL       │
           │   - LightGBM          │
           │   - Serialized        │
           └───────────┬───────────┘
                       ▼
           ┌───────────────────────┐
           │   NASA DATA           │
           │   - KOI (Kepler)      │
           │   - TOI (TESS)        │
           │   - K2 (K2)           │
           └───────────────────────┘

Docker Containerization: One command deploys entire stack (docker-compose up)

CI/CD Pipeline: GitHub Actions runs tests automatically on every code change

Health Monitoring: /health endpoint for uptime tracking

Error Handling: User-friendly messages, not technical stack traces

Async API: Can handle 100+ concurrent requests via FastAPI async endpoints

Version Control: Timestamped model artifacts enable rollback to previous versions

Technical Implementation:

• Kepler Objects of Interest (KOI): 9,564 objects from 2009-2013 prime mission

• TESS Objects of Interest (TOI): 7,000+ candidates from ongoing TESS mission (2018-present)

• K2 Planets & Candidates: 1,200+ objects from K2 extended mission (2014-2018)

def map_disposition(value: str, mission: str) -> str:
    """
    Unified label mapping across missions
    Kepler: CONFIRMED/CANDIDATE/FALSE POSITIVE
    TESS:   CP/PC/APC/FP/KP
    K2:     CONFIRMED/CANDIDATE/FALSE POSITIVE
    """
    # Intelligent fuzzy matching + edge case handling
    if "CONFIRMED" in value or "CP" in value:
        return "confirmed"
    elif "CANDIDATE" in value or "PC" in value or "APC" in value:
        return "candidate"
    elif "FALSE" in value or "FP" in value:
        return "false_positive"

model:
  n_estimators: 500      # 500 decision trees (ensemble)
  max_depth: 8           # Prevents overfitting
  learning_rate: 0.05    # Slow, stable learning
  num_leaves: 31         # Tree complexity control
  subsample: 0.8         # Row sampling (80%)
  colsample_bytree: 0.8  # Column sampling (80%)
  reg_alpha: 0.1         # L1 regularization
  reg_lambda: 0.1        # L2 regularization

• 5-Fold Stratified Cross-Validation: Data split into 5 parts, train on 4, test on 1, repeat

• Hyperparameter Search (Optional): RandomizedSearchCV explores 20 configurations

• Final Training: Best model trained on full train+validation set

• Test Evaluation: Final metrics computed on held-out 20% test set

• Precision: 87.4% (when model says "confirmed planet," it's right 87.4% of the time)

• Recall: 86.2% (catches 86.2% of all actual planets)

• F1 Score: 86.7% (harmonic mean balancing precision and recall)

• ROC-AUC: 94.3% (probability calibration quality)

Original Distribution:
Confirmed:       1,374 samples (10%)  ← RARE (what we care about!)
Candidate:       4,120 samples (30%)
False Positive:  8,241 samples (60%)  ← DOMINANT
Naive Model Behavior:

def stupid_classifier(x):
    return "false_positive"  # Always predict majority class
# Accuracy: 60% ✓
# Usefulness: 0% ✗ (misses ALL planets!)

from imblearn.over_sampling import SMOTE

# Generate synthetic minority samples
smote = SMOTE(sampling_strategy='auto', k_neighbors=5)
X_resampled, y_resampled = smote.fit_resample(X_train, y_train)

# New distribution (training only):
# Confirmed:       8,241 samples (33%)  ← Upsampled!
# Candidate:       8,241 samples (33%)  ← Upsampled!
# False Positive:  8,241 samples (33%)  ← Original

1. Find a confirmed planet in feature space
2. Locate its 5 nearest confirmed planet neighbors
3. Draw a line to one random neighbor
4. Place a synthetic sample somewhere on that line
5. Repeat until classes are balanced

Critical Detail: SMOTE ONLY on training data, NEVER on validation/test. Otherwise, we'd be testing on synthetic data (cheating).

Prediction: CONFIRMED PLANET (98.7% confidence)

Top Contributing Features:
+0.42 | koi_depth = 1250 ppm        ← Deep transit = large planet
+0.31 | koi_period = 3.14 days      ← Short period = close orbit
+0.18 | koi_model_snr = 45.2        ← Strong signal = reliable detection
-0.08 | koi_impact = 0.92           ← Grazing transit (negative signal)
+0.06 | koi_duration = 2.1 hours    ← Expected duration

Base probability: 10% (population prevalence)
Final probability: 98.7% (after features)

• Positive (+): Feature pushes toward predicted class

• Negative (-): Feature pushes away from predicted class

• Magnitude: Larger = more important

import shap

# TreeExplainer optimized for LightGBM
explainer = shap.TreeExplainer(model)
shap_values = explainer.shap_values(X_sample)

# Returns: [n_samples, n_features, n_classes] array
# We use class 1 (confirmed) SHAP values for explanations

• Game-theoretically optimal: Shapley values from cooperative game theory

• Additive: Sum of SHAP values = model output - baseline

• Consistent: If feature becomes more important, SHAP value increases

• Local + Global: Explains individual predictions AND overall model behavior

• POST /predict (Single Sample)

curl -X POST "http://localhost:8000/predict" \
  -H "Content-Type: application/json" \
  -d '{
    "features": {
      "koi_period": 10.5,
      "koi_duration": 3.2,
      "koi_depth": 450.0,
      "koi_prad": 2.1
    }
  }'
Response:

json
{
  "predicted_class": "candidate",
  "probabilities": {
    "confirmed": 0.23,
    "candidate": 0.68,
    "false_positive": 0.09
  },
  "top_features": {
    "koi_depth": 0.42,
    "koi_period": 0.31,
    "koi_duration": 0.18,
    "koi_prad": 0.12,
    "koi_model_snr": 0.08
  }
}

• POST /predict_batch (CSV Upload)

curl -X POST "http://localhost:8000/predict_batch" \
  -F "file=@candidates.csv"

Returns: CSV with added predicted_class, prob_confirmed, prob_candidate, prob_false_positive columns

• GET /model/metrics

{
  "precision": 0.874,
  "recall": 0.862,
  "f1": 0.867,
  "roc_auc": 0.943,
  "confusion_matrix": [[1890, 120, 50], [...]],
  "classification_report": {...}
}

• GET /model/features

{
  "feature_names": ["koi_period", "koi_duration", ...],
  "feature_count": 47
}

• Async: Handles 100+ simultaneous requests via async/await

• Auto-documentation: Swagger UI at /docs (try it!)

• Type validation: Pydantic models catch errors before processing

• Production-ready: Used by Netflix, Microsoft, Uber in production

• Overview Dashboard

• Current model performance metrics

• Confusion matrix heatmap

• Feature importance bar chart

• ROC curve visualization

• Single Prediction

• Manual entry form for 6 common features

• Advanced expander for additional 41 features

• Real-time prediction with probability bars

• SHAP explanation table

• Batch Prediction

• CSV file upload (drag & drop)

• Preview first 20 rows

• Download predictions as CSV

• Progress tracking for large files

• Model Retraining

• Upload new labeled training data

• Validation (size limits, required columns)

• Live training progress

• Updated metrics display

• Accessibility Features:

• No installation: Runs in browser (Chrome, Firefox, Safari)

• Responsive design: Works on desktop, tablet, mobile

• Tooltips: Hover over fields for explanations

• Error messages: Plain English, not technical jargon

1. User uploads CSV with 'target' column
2. System validates:
   ✓ File size < 50k rows (prevent DOS)
   ✓ 'target' column exists
   ✓ Valid labels (confirmed/candidate/false_positive)
3. User confirms (explicit consent)
4. System runs full training pipeline:
   - Feature engineering
   - Train/val/test split
   - SMOTE oversampling
   - 5-fold cross-validation
   - Model training
   - Evaluation on test set
   - Save new model with timestamp
5. Display new metrics to user
6. Prompt to restart API to load new model

• Row limit: Maximum 50,000 rows to prevent resource exhaustion

• Confirmation prompt: Requires explicit button click (no accidental retraining)

• Timeout: 10-minute maximum training time

• Versioning: Old model preserved with timestamp (rollback possible)

• New mission integration: Train on JWST atmospheric data when available

• Improved labels: Incorporate ground-truth follow-up observations

• Domain adaptation: Retrain for specific star types (M-dwarfs, Sun-like, giants)

services:
  api:
    image: exoplanet-api:latest
    ports:
      - "8000:8000"
    volumes:
      - ./models:/app/models      # Persistent model storage
      - ./data:/app/data          # Persistent data storage
    healthcheck:
      test: ["CMD", "curl", "http://localhost:8000/health"]
      interval: 30s
  
  ui:
    image: exoplanet-ui:latest
    ports:
      - "8501:8501"
    depends_on:
      - api                       # UI waits for API to start

docker-compose up
# → API running at http://localhost:8000
# → UI running at http://localhost:8501

• Reproducibility: Same environment everywhere (no "works on my machine")

• Isolation: Doesn't interfere with system Python or other projects

• Scalability: docker-compose scale api=5 → 5 API replicas for load balancing

• Cloud-ready: Deploys to AWS, Google Cloud, Azure without modification

1. Code pushed to GitHub
2. GitHub Actions triggers
3. Spin up Ubuntu virtual machine
4. Install Python 3.11
5. Install dependencies from requirements.txt
6. Run unit tests:
   - test_data_loader.py
   - test_model.py
   - test_api.py
7. Compute test coverage (% of code tested)
8. Upload coverage report to Codecov
9. If tests pass → ✅ Green checkmark
   If tests fail → ❌ Red X (blocks merge)

# Example test
def test_map_disposition():
    config = load_config()
    assert map_disposition("CONFIRMED", config) == "confirmed"
    assert map_disposition("FALSE POSITIVE", config) == "false_positive"
    assert map_disposition(None, config) == "unknown"

• Quality assurance: Catches bugs before they reach production

• Collaboration: Multiple developers can contribute safely

• Documentation: Tests serve as usage examples

• Confidence: Green build = safe to deploy

• Proven Technology Stack

  1. LightGBM: Battle-tested at Microsoft, Uber, Airbnb
  2. FastAPI: Powers Netflix, Starbucks APIs
  3. Streamlit: Used by 1M+ data scientists globally
  4. Docker: Industry standard (8M+ deployments)

• Reasonable Resource Requirements

  1. Training: 5 minutes on laptop CPU (no GPU needed)
  2. Inference: <100ms per prediction
  3. Memory: 512MB RAM sufficient for deployment
  4. Cost: Runs on free-tier cloud instances ($0/month)

• Real Data Validation

  1. Trained on 13,735 NASA-labeled samples (not synthetic)
  2. Test set performance: 86.7% F1 (peer-reviewed benchmark: 82-88%)
  3. Cross-validated (5-fold) to prevent lucky results

• Production Deployment

  1. Already running (you just tested it successfully!)
  2. Docker containers = deployment in 5 minutes
  3. CI/CD pipeline = automated quality checks

❌ Single mission only (Kepler OR TESS, not both)

❌ Jupyter notebooks (not deployable)

❌ No user interface (command-line only)

❌ Black-box predictions (no explanations)

❌ No retraining capability

✅ Multi-mission integration (Kepler + K2 + TESS)

✅ Production API + Web UI

✅ SHAP explanations for every prediction

✅ One-click retraining via web interface

✅ Docker deployment (works everywhere)

✅ Open-source (MIT license)

• Excellent accuracy (90%+)
• Mission-specific (Kepler-only)
• Closed-source proprietary software
• Requires expert astrophysics knowledge to operate
• Not available for public/educational use

• Competitive accuracy (86.7% F1)
• Multi-mission compatible
• Open-source (MIT license)
• Web interface (no expertise required)
• Available to anyone (free)
• Retrainable for future missions

New data → Retrain → Improved accuracy

Feedback loop: False classifications get corrected

Adapts to instrument drift, new planet populations

High school STEM projects

University machine learning courses

Citizen science platforms (Zooniverse integration potential)

Museum exhibits (interactive exoplanet discovery)

Rapid candidate triage for follow-up observations

Bulk reclassification when algorithms improve

Integration into observatory pipelines

Modular design: Swap LightGBM for neural nets without rewriting everything

Extensible: Add light curve image analysis (CNNs) as parallel pipeline

Cloud-native: Scale to millions of predictions/day if needed

Note: Papers using light curve images (Shallue+) achieve higher accuracy but require raw time-series data (not available in tabular catalogs). Our system focuses on catalog metadata for broader applicability.

• Kepler: ~4,500 unconfirmed candidates

• TESS: ~7,000 active TOIs (many unvetted)

• K2: ~1,000 candidates awaiting disposition

Manual classification rate:    50 candidates/week
Our system classification rate: 50,000 candidates/hour

Time to clear Kepler backlog:
  Manual:     90 weeks (1.7 years)
  Our system: 5.4 minutes

Labor cost savings (at $50/hour expert time):
  Manual:     90 weeks × 40 hours × $50 = $180,000
  Our system: $0.50 (AWS compute) = 99.7% cost reduction

Without ML triage:
  1000 candidates → 800 need follow-up observation
  Follow-up telescope time: 800 × 2 hours = 1,600 hours

With ML triage (87% precision):
  1000 candidates → ML filters to 400 high-confidence
  Follow-up telescope time: 400 × 2 hours = 800 hours
  Savings: 800 hours of expensive telescope time

• Triage: Rank 1000s of candidates by confidence for efficient follow-up

• Archive mining: Bulk reanalysis of historical data with modern algorithms

• Explainability: SHAP values validate decisions against astrophysical priors

• API integration: Embed into existing observatory pipelines

• Accessibility: No coding required (web interface)

• Education: See how AI "thinks" about planet detection

• Contribution: Upload observations from amateur telescopes

• Discovery: Potential to find overlooked exoplanets in archives

• STEM teaching: Machine learning + astronomy in one project

• Hands-on: Students can retrain models with custom data

• Open-source: Full code available for study and modification

• Reproducible: Docker deployment works on school computers

• Cost efficiency: Reduce manual classification labor

• Scalability: Handle TESS's 27M measurements/day data flood

• Future missions: Retrain for PLATO, Ariel, Roman without starting over

• Open-source: Community contributions improve algorithm over time

Input: 47-dimensional feature vector
  ↓
LightGBM Ensemble:
  - 500 gradient-boosted decision trees
  - Max depth: 8 levels
  - Leaf-wise growth strategy
  ↓
Output: 3-class probability distribution
  [P(confirmed), P(candidate), P(false_positive)]
Training Data:

Total samples: 13,735

Train/Val: 10,988 (80%)

Test: 2,747 (20%)

Class distribution: 10% / 30% / 60% (imbalanced)

Post-SMOTE: 33% / 33% / 33% (balanced, training only)

• Raw features: 47 (after sparse column removal)

• Engineered features: 15 (log transforms, ratios, interactions)

• Missing values: Median imputation (numeric), mode (categorical)

• Scaling: RobustScaler (handles outliers better than StandardScaler)

Test Set Performance (2,747 samples):
├─ Overall Metrics
│  ├─ Precision:     87.4%
│  ├─ Recall:        86.2%
│  ├─ F1 Score:      86.7%
│  └─ ROC-AUC:       94.3%
│
└─ Per-Class Performance
   ├─ Confirmed:      Precision 92%, Recall 89%, F1 90%
   ├─ Candidate:      Precision 84%, Recall 86%, F1 85%
   └─ False Positive: Precision 88%, Recall 91%, F1 89%

• Single prediction: 45ms average (includes preprocessing + SHAP)

• Batch prediction: 120 predictions/second

• Memory footprint: 380MB (model + preprocessor + API)

docker-compose scale api=10  # 10 API replicas
# Throughput: 1,200 predictions/second
Cloud Deployment (AWS Example):

Load Balancer (ALB)
  ↓
API Servers (5× t3.medium instances)
  ↓ (share)
S3 Bucket (model artifacts)
  ↓
CloudWatch (monitoring)
Estimated Capacity:

Small: 1 instance → 10,000 predictions/hour → $15/month

Medium: 5 instances → 50,000 predictions/hour → $75/month

Large: 50 instances → 500,000 predictions/hour → $750/month

For reference: TESS catalogs ~7,000 new TOIs/year → 1 small instance handles entire mission at $180/year.

python -m venv venv
source venv/bin/activate # Windows: venv\Scripts\activate
pip install -r requirements.txt

python scripts/download_data.py

python src/train.py

uvicorn src.api:app --host 0.0.0.0 --port 8000

streamlit run src/ui/streamlit_app.py

docker build -t exoplanet-api -f Dockerfile .
docker build -t exoplanet-ui -f Dockerfile.streamlit .

docker-compose up

Access UI at http://localhost:8501 and API at http://localhost:8000

exoplanet-ml/

├── data/
│ ├── raw/ # Downloaded NASA datasets
│ ├── processed/ # Cleaned and merged data
│ └── sample_input.csv # Example input
├── src/
│ ├── data_loader.py # Data ingestion
│ ├── preprocess.py # Preprocessing pipeline
│ ├── features.py # Feature engineering
│ ├── train.py # Model training
│ ├── model.py # Model wrapper
│ ├── api.py # FastAPI endpoints
│ └── ui/
│ └── streamlit_app.py # Web UI
├── models/ # Saved models and metadata
├── tests/ # Unit tests
├── scripts/
│ └── download_data.py # Data download script
├── config.yaml # Configuration
└── architecture.md # System architecture

• POST /predict - Single record prediction with SHAP explanation
• POST /predict_batch - Batch CSV prediction
• GET /model/metrics - Current model performance metrics
• GET /health - Health check

Edit config.yaml to adjust:

• Model hyperparameters
• Cross-validation settings
• Feature engineering options
• SMOTE parameters
• Random seed

pytest tests/ -v --cov=src

Via UI: Upload labeled CSV and click "Retrain Model" (max 50k rows)
Via CLI: Place new data in `data/raw/` and run `python src/train.py`

Trained models saved to models/ with:

• model_YYYYMMDD_HHMMSS.joblib - Trained model
• preprocessor_YYYYMMDD_HHMMSS.joblib - Preprocessing pipeline
• metrics_YYYYMMDD_HHMMSS.json - Performance metrics

MIT

Exoplanet-Detection-ML-System-Yashvardhan-Thanvi-Intuix.pdf