🔭 astrophysics

Graph-Based Light-Curve Features for Robust Transient Classification

This paper demonstrates that mapping astronomical light curves to multiple visibility-graph representations and extracting compact network descriptors enables robust, competitive multiclass transient classification using standard tree-based learners, achieving a macro-F1 of 0.622 on a quality-controlled MANTRA benchmark subset without requiring bespoke deep learning architectures.

Original authors: Jesús D. Petro-Ramos, David J. Ruiz-Morales, D. Sierra-Porta

Published 2026-03-25

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Jesús D. Petro-Ramos, David J. Ruiz-Morales, D. Sierra-Porta

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are a detective trying to identify different types of people walking down a busy street at night. Some are sprinting, some are strolling, some are dancing, and some are just standing still. But here's the catch: you can only see them through a foggy window, and your view is interrupted by passing clouds. Sometimes you catch a glimpse of a person for a split second, then they disappear for an hour, then you see them again.

This is exactly the challenge astronomers face when they look at light curves. A light curve is just a graph showing how bright a star or galaxy is over time. Astronomers need to sort these "stars" into different categories (like exploding supernovas, active black holes, or just regular stars) to understand the universe. But the data is messy, irregular, and full of gaps.

This paper presents a clever new way to solve this puzzle using Graph Theory (the math of connections) instead of traditional statistics. Here is the story of how they did it, explained simply:

1. The Problem: The "Foggy Window"

Traditional methods try to measure specific things about the light curve, like "how much did it jump?" or "how often does it repeat?" It's like trying to describe a person by counting how many times they blinked. If the fog (data gaps) is thick, you miss the blinks, and your description fails. Also, some types of stars are very rare (like a unicorn), while others are common (like a pigeon). This makes it hard for computers to learn to spot the rare ones.

2. The Solution: Turning Time into a Map

The authors decided to stop looking at the light curve as a line and start looking at it as a map of connections. They used a concept called a Visibility Graph.

The Analogy: Imagine the light curve is a mountain range. If you stand on one peak, can you see another peak?
- Horizontal Visibility: You can see a neighbor if the ground between you isn't higher than the lowest point of the two of you.
- Directed Visibility: You can only look forward in time (like looking down a road).
- Weighted Visibility: You also consider how "loud" the difference is between the two peaks (the amplitude) and how shaky your binoculars are (the measurement error).

By connecting every point that can "see" each other, they turn a messy squiggly line into a network of friends. A smooth, boring star becomes a simple, straight line of friends. A chaotic, exploding star becomes a complex web where everyone is connected to everyone else in weird ways.

3. The Detective's Toolkit: Measuring the Map

Once they turned the light curve into a map, they didn't need to guess what the star was doing. They just asked the map simple questions:

How popular is each point? (Degree): Does one point connect to many others? (This happens during a sudden burst of light).
How clumpy is the group? (Clustering): Do friends of friends also know each other?
Is the map balanced? (Assortativity): Do popular points tend to hang out with other popular points?
How fast can you get from A to B? (Efficiency): Is the network a tight circle or a long, winding road?

These questions turn the complex time-series data into a simple list of numbers (features) that a computer can easily understand.

4. The Experiment: The "Quality Control" Filter

The researchers used a famous dataset called MANTRA, which contains thousands of these light curves. However, the original dataset was a bit like a junk drawer: it had too many "boring" stars (Non-Transient) and not enough of the interesting, rare ones.

So, they cleaned the data:

They threw away any star that didn't have enough observations (less than 100 "glimpses").
They capped the number of "boring" stars so the computer wouldn't just guess "boring star" every time to get a high score.

This created a fair playing field where the computer had to actually learn the differences between the classes.

5. The Results: A New Kind of Detective

They taught a computer (using a smart algorithm called LightGBM) to look at these "map features" and guess the star's identity.

The Score: The computer got about 62% right on the hard, multi-class test.
The Comparison: The previous best methods on the full, messy dataset got about 53%.
The Winner: The combination of all three map types (Horizontal, Directed, and Weighted) worked best.

Why did it work?

Weighted Maps caught the "loud" events (like flares) because they paid attention to how big the jumps were.
Directed Maps caught the "direction" of time (like a supernova rising and falling), which is different from a star that just fluctuates randomly.
Standard Maps caught the overall shape and structure.

6. The Takeaway

This paper shows that you don't need a super-complex, deep-learning AI (which is like a giant, black-box brain) to solve this problem. Sometimes, you just need to change your perspective.

By turning a messy, jagged line of light into a social network of points, the astronomers created a simple, robust way to sort the stars. It's like realizing that to identify a person, you don't need to count their steps; you just need to see who they are standing next to and how they are connected to the crowd.

In short: They turned a messy time-travel puzzle into a simple friendship map, and the computer solved it much better than before. This method is fast, easy to understand, and works well even when the data is incomplete or noisy.

1. Problem Statement

The paper addresses the challenge of automated transient classification in time-domain astronomy. As large-scale synoptic surveys (e.g., LSST) generate massive volumes of light curves, there is an urgent need for efficient, automated methods to distinguish between diverse astrophysical sources without relying on costly spectroscopic follow-up.

Key challenges identified include:

Data Irregularities: Light curves suffer from irregular sampling, seasonal gaps, and heteroscedastic (non-uniform) measurement errors.
Class Imbalance: Scientifically interesting transients are rare compared to abundant background populations (e.g., non-transient stars), biasing machine learning models toward majority classes.
Morphological Ambiguity: Similar light-curve shapes (e.g., Active Galactic Nuclei vs. Blazars, or Supernovae vs. Cataclysmic Variables) often lead to confusion, especially when data is sparse.
Limitations of Current Methods: Traditional approaches rely on hand-crafted statistical features (moments, variability indices) which require expensive engineering and struggle with noisy, gap-ridden data. Deep learning approaches often require bespoke architectures and large datasets.

2. Methodology

The authors propose a graph-based representation of light curves that transforms irregular time-series data into network structures, preserving temporal and geometric relationships without complex preprocessing.

A. Data Preparation

Dataset: The study uses the MANTRA benchmark, a curated dataset of single-band photometric light curves with eight classes: Supernovae (SN), Cataclysmic Variables (CV), Active Galactic Nuclei (AGN), High Proper Motion stars (HPM), Blazars, Stellar Flares, Other, and Non-Transient (Non-Tr.).
Quality Control & Balancing: To ensure stable graph construction, the authors created a specific evaluation subset:
- Minimum Coverage: Objects must have $N_{min} = 100$ epochs after cleaning.
- Class Balancing: The dominant "Non-Tr." class was capped at 283 objects to prevent the model from being overwhelmed by easy negatives, ensuring macro-averaged metrics remain informative for minority classes.
- Resulting Subset: 1,705 objects across 8 classes.

B. Graph Construction (Visibility Graphs)

Each light curve is mapped to three distinct graph views based on the Visibility Graph concept:

Horizontal Visibility Graph (HVG): Two nodes (observations) are connected if all intermediate points lie strictly below the horizontal line connecting them. This captures global shape and is invariant to monotonic transformations.
Directed HVG (DHVG): Edges are oriented forward in time ( $i \to j$ ). This captures temporal asymmetry and irreversibility (e.g., distinguishing a rise from a decay).
Weighted HVG (W-HVG): Edges are assigned weights based on amplitude contrast ( $|x_i - x_j|$ ) or normalized by measurement uncertainty ( $\sigma$ ). This incorporates heteroscedastic noise and amplitude information.

C. Feature Extraction

From these graphs, the authors extract compact, length-aware network descriptors:

Degree/Strength Statistics: Moments (mean, std, skew), tail proxies via exponential fits.
Clustering & Motifs: Triangle counts, transitivity, reciprocity, and small subgraph frequencies.
Assortativity: Degree-degree correlations (Pearson) for both undirected and directed networks.
Path/Efficiency: Global efficiency and average shortest-path length on the giant component.
Spectral Summaries: Leading eigenvalues of adjacency and Laplacian matrices, spectral radius, and algebraic connectivity.

D. Learning Algorithm

Models: Tree-based ensembles (Random Forest, Extremely Randomized Trees, LightGBM, XGBoost).
Validation: Object-level stratified 5-fold cross-validation (keeping all epochs of an object within a single fold to prevent data leakage).
Objective: Maximize Macro-F1 to balance performance across minority and majority classes.

3. Key Contributions

Survey-Agnostic Representation: Demonstrates that visibility graphs provide a simple, robust bridge between irregular photometric time series and standard classifiers, eliminating the need for bespoke deep learning architectures or heavy feature engineering.
Complementary Feature Triad: The study identifies that combining three graph types yields superior results:
- Weighted features capture amplitude and uncertainty.
- Directed features capture temporal asymmetry.
- Undirected topology captures global shape and local closure.
Reproducible Benchmarking: The authors release code, feature definitions, and the specific list of object IDs used in their quality-controlled subset to facilitate exact replication and future extensions.
Quality-Controlled Evaluation: By explicitly addressing class imbalance and data quality (capping Non-Tr. and enforcing minimum epochs), the paper provides a more rigorous evaluation of classifier performance on minority classes than previous full-dataset baselines.

4. Results

Overall Performance: The best configuration (LightGBM using combined HVG + DHVG + W-HVG features) achieved:
- Macro-F1: $0.622 \pm 0.010$
- Accuracy: $0.661 \pm 0.010$
Comparison: While the published MANTRA baseline reports a Macro-F1 of 0.528 on the full dataset, the authors note this is not a direct comparison due to different class priors. However, their approach shows significant improvements in Macro-Precision (64.55% vs. 49.12%) and competitive performance on the balanced subset.
Per-Class Analysis:
- Strong Performance: High F1 scores for CV (79.59%), HPM (76.06%), and Non-Tr. (96.56%).
- Challenging Classes: AGN, Blazar, and SN remain difficult, with confusions concentrated in this block.
- Error Patterns: SN light curves are often misclassified as AGN/Blazar when partial coverage misses the full rise-fall morphology. HPM and CV show some confusion due to similar regular trends.
Feature Importance:
- Weighted descriptors (strength and disparity from W-HVG) were the most important, highlighting the value of amplitude and uncertainty information.
- Directed features (in/out-degree dispersion) contributed significantly by capturing temporal irreversibility.
- Undirected topology (assortativity, clustering, spectral radius) provided global shape context.

5. Significance and Outlook

Efficiency: The method offers a computationally efficient alternative to deep learning, suitable for real-time ingestion of high-throughput alert streams.
Interpretability: The graph-based features are interpretable (e.g., "strength" relates to amplitude contrast), unlike black-box neural embeddings.
Robustness: The approach handles irregular sampling and gaps naturally, as the graph construction depends only on relative ordering and local visibility.
Future Work: The authors suggest extending this pipeline to the complete MANTRA dataset and other surveys. They also propose using class-specific decision thresholds or cost-sensitive training to further resolve the confusion between AGN, Blazars, and Supernovae.

In conclusion, the paper establishes that visibility graphs are a powerful, survey-agnostic tool for transient classification, offering competitive performance with a simple, reproducible pipeline that effectively handles the unique noise and sampling characteristics of astronomical time-series data.