Kepler KOI Exoplanet Classifier

GIF
MLP training curves — The MLP learns quickly and stays stable across epochs, with train and validation performance closely aligned.
GIF
Transformer training curves — The transformer steadily improves during training and reaches strong validation performance
MLP test diagnostics — Final test set performance for the MLP, showing that it classifies almost all KOI signals correctly
MLP embedding evolution — A view of how the MLP gradually reshapes raw KOI features into a more separable latent space.
Transformer test diagnostics — Final test set performance to transformer, with strong separation between true planets and false positives
Transformer embedding evolution — The transformer’s learned feature space becomes more organized as training progresses

Inspiration

I’ve always loved the idea that somewhere out there, planets are orbiting stars we can barely see. But when I started reading about exoplanets, I realized something surprising: astronomers don’t usually “see” these planets at all. They stare at long, noisy light curves and tiny dips in brightness and try to decide, one by one, whether a signal is a real world or just a false alarm.

When I saw this challenge using NASA Kepler data, it felt like the perfect chance to step into that process myself. Instead of a toy dataset, this is the same KOI (Kepler Object of Interest) catalog scientists use, with real flags, probabilities, and messy measurements. I wanted to see if I could build something that not only scores well, but actually looks like a tool an astronomer could use.

What it does

Kepler KOI Exoplanet Classifier is an end‑to‑end pipeline that takes genuine Kepler KOI and FPP data and learns to separate real planet candidates from false positives.

In practical terms, my project:

Loads and cleans NASA KOI cumulative and FPP (false positive probability) tables.

Builds a feature set from transit properties (period, depth, duration, SNR) and stellar parameters (temperature, radius, log g), plus vetting flags and FPP outputs.

Trains several classical machine learning models (Random Forest, Logistic Regression, SVM, KNN) and a feed‑forward neural network on the same data. train_exoplanet_koi.py

Evaluates them using accuracy, macro F1, ROC‑AUC, and confusion matrices on a proper train/validation/test split. model_results.csv

Saves the best model and all metrics/plots so the results can be reproduced later.

The goal is simple to say but hard to do well: for any KOI, tell you whether it looks more like a real exoplanet or a false positive, and show you why the model thinks so.

How we built it

I built everything in Python, working in VS Code with GitHub Copilot and managing the project in a clean repo structure.

The main steps:

Data & preprocessing I started from the NASA KOI cumulative table and the DR25 KOI FPP table, then merged them on kepoi_name. From there I selected physically meaningful columns and handled missing values carefully (median imputation for numeric features, zero for flags). cumulative_2026.07.08_22.48.21.csv +1

Feature engineering I added features like transit duty cycle, SNR per transit, and simple combinations linking insolation and stellar properties. I kept features that have a clear physical or vetting interpretation instead of blindly throwing everything into the model.

Model training I used scikit‑learn Pipelines and ColumnTransformers to keep preprocessing and training tied together. On top of that, I implemented:

Random Forest, Logistic Regression, SVM‑RBF, and KNN.

A PyTorch feed‑forward neural network tuned for tabular data (layers, dropout, early stopping).

Evaluation & outputs Every model is evaluated on validation and test splits, and the script saves confusion matrices, ROC curves, and a model_results.csv summary as well as serialized model objects (.joblib and .pt). This all lives in the GitHub repo so someone else can rerun or inspect the pipeline. model_results.csv +1

Throughout the build I tried to keep the code “boring and reliable” rather than flashy: clear function names, one script for KOI-only data, another for KOI+FPP, and a simple run_pipeline.py entrypoint.

Challenges we ran into

The biggest challenge was the data itself. Real NASA tables are not clean Kaggle datasets:

Some fields are missing or inconsistent.

Several columns look similar but mean different things.

It’s easy to accidentally leak information from labels into features if you are not careful.

I spent time reading KOI documentation, figuring out which flags were safe to use and which would basically hard‑code the answer. Getting a good split between confirmed planets, candidates, and false positives while keeping the science honest was harder than just pressing “fit()”.

Another challenge was reproducibility. It’s one thing to get good metrics in a notebook; it’s another to turn that into a repository that other people can run. Cleaning up the folder structure, adding a proper .gitignore, pushing to GitHub, and making sure the training scripts work on a fresh clone took real effort and a few mistakes along the way.

Accomplishments that we’re proud of

A few things I’m especially proud of:

The project uses real NASA Kepler KOI and FPP catalogs, not a preprocessed classroom dataset. That makes the problem (and the solution) feel more like actual research than a toy exercise. q1_q17_dr25_koifpp_2026.07.08_22.50.18.csv +1

I built and compared both classical ML and a deep neural network on the same feature space, instead of claiming “deep learning” without a fair baseline.

The models don’t just spit out a probability; they come with:

Confusion matrices that show where the model works and where it fails.

ROC curves that show tradeoffs between false positive and true positive rates.

Feature importance for tree‑based models to highlight which signals matter most.

Seeing the confusion matrices all line up with very few misclassifications, knowing that each square corresponds to real candidates and real false positives, was a great feeling.

What we learned

I learned that in scientific ML, domain understanding matters as much as the algorithms. Transit depth, SNR, and false-positive flags are not just features; they encode the entire story of how the signal was recorded and vetted.

I also learned the value of proper experiment design:

Stratified train/validation/test splits.

Macro F1 for balanced attention to both classes.

Avoiding data leakage between features and labels.

Keeping training and evaluation logic in clean, reusable scripts.

On the engineering side, working with real‑world data, version control, and a GitHub repo forced me to treat this less like a school assignment and more like an actual project that someone else might pick up and extend.

What’s next for Kepler KOI Exoplanet Classifier

This is a good v1, but there are lots of ideas I want to explore:

Move beyond strict binary classification and build a multi‑class model that distinguishes confirmed planets, strong candidates, and clear false positives.

Experiment with more expressive neural architectures for tabular scientific data, and possibly combine tabular features with simple summaries from light curves.

Wrap the model in a small web interface, where users can upload KOI‑style feature rows, see predictions, and inspect which features drove the decision.

Add better explanation tools (e.g., SHAP values or attention visualizations) to connect predictions back to physical intuition for astronomers.