Astro Py: Exoplanet Detection & Transit Photometry Deep Dive

01. The Spark & Problem Statement

My journey into astroinformatics began with an ISRO hackathon problem statement. I had always been captivated by the scale of the cosmos, but looking at actual space telescope data revealed a massive challenge: NASA’s Kepler and TESS missions have collected hundreds of thousands of stellar light curves, each containing subtle dips in brightness.

While existing machine learning models typically perform binary classification (Planet vs. Non-Planet), real-world astronomical catalogs require deeper discrimination. Thousands of non-planetary dips are caused by authentic astrophysical phenomena like eclipsing binaries or background stellar variability. I set out to explore whether a neural network could identify not just if a transit dip is a planet, but specifically which astronomical event produced the signal.

02. Astronomy & Transit Photometry Fundamentals

When an exoplanet orbits in front of its host star relative to our line of sight, it blocks a tiny fraction of the star's emitted light. This creates a periodic dip in the measured brightness over time—known as a transit light curve.

Because typical Earth-sized exoplanets cause brightness drops of less than 0.01% (100 parts per million), raw light curves are heavily corrupted by stellar flares, instrumental jitter, and cosmic ray hits.

03. Kepler & TESS Data Archives

NASA's MAST (Mikulski Archive for Space Telescopes) hosts the complete catalog of Kepler Objects of Interest (KOI). The catalog partitions detections into:

• Confirmed Exoplanets: Statistically validated or spectroscopically confirmed planets.
• Planet Candidates: Periodic transit-like signals that pass initial automated vetting.
• False Positives: Non-planetary astronomical events or instrumental artifacts.

04. Astrophysical False Positives & Mimics

Exoplanet vetting models fail most often when encountering astronomical mimics:

1. Eclipsing Binaries (EB): Two stars orbiting each other, causing deeper V-shaped or alternating primary/secondary eclipses.
2. Background Eclipsing Binaries (BEB): A faint background binary aligned along the same pixel line of sight, diluting the eclipse depth to mimic an exoplanet.
3. Centroid Offset Motion: Significant shifts in the center of light flux during transit indicate the signal originates from a nearby companion star rather than the target star.
4. Instrumental & Systematic Noise: Spacecraft momentum wheel desaturations and thermal drift.

05. Lightkurve & Signal Processing Pipeline

Raw Target Pixel Files (TPF) are converted into high-signal time series through a multi-stage preprocessing pipeline:

06. Evolution of State-of-the-Art Architectures (2015–2025)

Before designing my model, I analyzed how the research field progressed over the past decade:

07. 5-Class Multi-Branch CNN Design

Inspired by AstroNet and ExoNet, my custom architecture feeds two distinct temporal resolutions into parallel 1D convolutional branches:

• Global View Branch (2001 bins): Analyzes the complete orbital phase to catch secondary eclipses, out-of-transit variations, and stellar flares.
• Local View Branch (201 bins): Zooms tightly into the transit ingress/egress profile to distinguish U-shaped planetary transits from V-shaped grazing eclipses.

08. Code Implementation Snippet

Here is the core PyTorch architecture implementation combining dual 1D convolutional feature extractors with a unified multi-layer classifier:

import torch
import torch.nn as nn

class MultiBranchAstroCNN(nn.Module):
    def __init__(self, num_classes=5):
        super(MultiBranchAstroCNN, self).__init__()
        
        # Global View Branch (2001 time bins)
        self.global_branch = nn.Sequential(
            nn.Conv1d(in_channels=1, out_channels=32, kernel_size=5, padding=2),
            nn.ReLU(),
            nn.MaxPool1d(kernel_size=2),
            nn.Conv1d(32, 64, kernel_size=5, padding=2),
            nn.ReLU(),
            nn.MaxPool1d(kernel_size=2),
            nn.AdaptiveAvgPool1d(16)
        )
        
        # Local View Branch (201 time bins)
        self.local_branch = nn.Sequential(
            nn.Conv1d(in_channels=1, out_channels=32, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool1d(kernel_size=2),
            nn.Conv1d(32, 64, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool1d(kernel_size=2),
            nn.AdaptiveAvgPool1d(16)
        )
        
        # Fully Connected Classification Head
        self.classifier = nn.Sequential(
            nn.Linear(64 * 16 * 2, 256),
            nn.ReLU(),
            nn.Dropout(0.4),
            nn.Linear(256, 128),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(128, num_classes)
        )
        
    def forward(self, x_global, x_local):
        feat_global = self.global_branch(x_global).flatten(start_dim=1)
        feat_local = self.local_branch(x_local).flatten(start_dim=1)
        
        combined = torch.cat([feat_global, feat_local], dim=1)
        return self.classifier(combined)

09. Key Insights & Experimental Findings

Working on this research yielded several crucial takeaways for applying machine learning to astronomical data:

• Domain Knowledge Over Raw Architecture: Phase folding precision (correct orbital period determination) mattered significantly more than adding additional dense layers. A slightly misaligned phase period ruins feature alignment across all convolutional filters.
• Complementary Views are Crucial: Models trained solely on Global Views missed faint shallow transits, while models trained solely on Local Views misclassified secondary eclipsing binaries. The dual-branch concatenation was vital.
• Severe Class Imbalance: True planets comprise less than 15% of initial pipeline detections. Using focal loss and stratified batch sampling prevented the network from collapsing into trivial majority-class predictions.

10. Future Research Directions

I am actively expanding this pipeline to incorporate:

1. Self-Attention Transformers: Applying Temporal Attention to dynamically weight transit dip phases without requiring fixed binning.
2. TESS Full Frame Images (FFI): Processing 2-minute cadence time series across thousands of southern/northern sky sectors.
3. Integration with Gaia DR3: Leveraging stellar parallax and radius constraints for physical validation.