🔭 astrophysics

Neutrino Fingerprints: Image-Based Encodings of IceCube Events for CNN Direction Reconstruction

This paper introduces "neutrino fingerprints," a novel image-based encoding of IceCube detector data that enables a ResNet18 convolutional neural network to achieve competitive direction reconstruction accuracy (1.10 rad mean angular error) for neutrino events.

Original authors: Floriano Tori, Brecht Verbeken, Vincent Ginis

Published 2026-06-03

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Floriano Tori, Brecht Verbeken, Vincent Ginis

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 the IceCube Neutrino Observatory as a giant, three-dimensional fishing net made of 5,160 light-sensitive eyes, buried deep inside a cubic kilometer of Antarctic ice. When a ghostly particle called a neutrino smashes into the ice, it creates a flash of light (Cherenkov radiation) that ripples through the ice, hitting these "eyes" at slightly different times and with different brightness levels.

The big challenge for scientists is: Where did that neutrino come from?

Usually, figuring this out is like trying to guess the direction of a shout in a dark forest just by listening to a few scattered echoes. It requires complex math and massive computing power.

The "Neutrino Fingerprint" Idea

The authors of this paper asked a simple question: What if we stopped treating this data as a messy list of numbers and instead turned it into a picture?

They invented a method they call "Neutrino Fingerprints." Here is how they did it:

The Grid: Imagine a blank 72-by-72 square grid (like a small pixelated image).
The Mapping: They assigned every single one of the 5,160 light detectors in the ice to a specific square (pixel) on this grid. It's like a seating chart where every detector has its own seat.
The Colors: Instead of just writing down "Detector #45 hit at 5 seconds," they painted the pixel for Detector #45 with specific colors:
- Red: Represents when the light hit (timing).
- Green: Represents how bright the hit was (charge).
- Blue: Represents the difference between the time and the brightness. This is like a "contrast" filter that highlights the edges of the light wave, which is crucial for figuring out direction.

If a detector didn't see anything, its pixel stays white (blank). If it did see something, it gets a colorful tint.

The "AI Detective"

Once they turned the messy data into these colorful 72x72 images, they fed them into a standard type of Artificial Intelligence called a Convolutional Neural Network (CNN).

Think of a CNN as a very good detective that is trained to look at pictures and find patterns. Usually, these detectives are used to recognize cats, dogs, or faces. In this case, the "face" is the pattern of light hitting the ice, and the "identity" the detective is trying to find is the direction the neutrino was traveling.

What Did They Find?

The authors trained this AI detective using 140 million simulated neutrino events (like showing it millions of practice photos).

The Result: The AI managed to guess the direction of the neutrino with an average error of about 1.10 radians (roughly 63 degrees).
The Comparison: The absolute best teams in a recent international competition (who used much more complex, heavy-duty AI models) got an error of about 0.95 radians.
The Takeaway: While their "simple picture" method wasn't the absolute winner, it was surprisingly close. It proved that you don't always need the most complicated, expensive AI to get a good answer. A simple, interpretable picture-based approach can do a solid job.

Why Does This Matter?

The paper argues that this method is valuable because it is transparent.

The "Black Box" Problem: Many advanced AI models are like black boxes; you put data in, and a result comes out, but you have no idea why the AI made that choice.
The "Fingerprint" Advantage: With this method, if the AI makes a mistake, scientists can look at the "fingerprint" image and see exactly which pixels (detectors) the AI was looking at. It's like looking at a sketch and saying, "Ah, it guessed the direction based on that bright red spot here."

Summary

The paper demonstrates that by turning complex, scattered scientific data into a simple, colorful image (a "fingerprint"), we can use standard, easy-to-understand AI tools to solve difficult physics problems. It's a reminder that sometimes, a clever way of looking at the data (turning it into a picture) is just as powerful as building a more complex machine.

Technical Summary: Neutrino Fingerprints for IceCube Direction Reconstruction

Problem Statement
Reconstructing the direction of incoming neutrinos in the IceCube Neutrino Observatory is a critical inverse problem in astrophysics. The detector consists of 5,160 photomultiplier tubes arranged in a sparse, irregular 3D grid within Antarctic ice. Traditional reconstruction algorithms rely on analytic approximations of photon transport likelihoods; while they can achieve sub-degree angular resolution, their high computational cost renders them impractical for the massive datasets (140 million events) generated by the IceCube–Neutrinos in Deep Ice Kaggle competition. While recent approaches have shifted toward Graph Neural Networks (GNNs) and Transformers to handle this irregularity, this work investigates whether Convolutional Neural Networks (CNNs), traditionally suited for regular grids, can remain competitive through novel data encoding.

Methodology
The core contribution of the paper is the introduction of "neutrino fingerprints," a deterministic image-based encoding that transforms sparse, variable-length pulse data into fixed-size images suitable for standard CNNs.

Data Encoding (Neutrino Fingerprints):
- Structure: Each event is mapped to a $72 \times 72 \times 3$ image. The mapping uses a row-major rasterization where each pixel corresponds to a specific detector index ( $d \in \{0, \dots, 5159\}$ ). Pixels corresponding to detectors with no registered pulses are filled with a constant white background.
- Feature Extraction: For each active detector, two scalar features are extracted from the pulse sequence: total charge ( $Q_d$ ) and earliest arrival time ( $T_d$ ).
- Normalization: To handle the vast variability in event multiplicities and energies, these features are normalized per event across the set of active detectors ( $D$ ) to a range of $[0, 255]$ .
- Channel Definition: The RGB channels are defined as:
  - Red ( $R_d$ ): Normalized arrival time ( $T_d$ ), emphasizing photon arrival gradients.
  - Green ( $G_d$ ): Normalized charge ( $Q_d$ ), spotlighting relative brightness.
  - Blue ( $B_d$ ): The absolute difference $|R_d - G_d|$ . This "opponent" channel highlights boundaries where timing and light yield diverge (often near the edges of the Cherenkov light cone), encoding strong directional cues.
Model Architecture:
- The authors employ a standard ResNet-18 architecture, chosen for its proven competitiveness in image recognition.
- The network is adapted for regression, predicting the zenith ( $\theta$ ) and azimuth ( $\phi$ ) angles via a final layer with two nodes.
- The GeLU activation function was selected over ReLU, SiLU, and ELU based on empirical performance.
Training and Loss Functions:
- The task is framed as regression on the unit sphere $S^2$ .
- Three loss functions were evaluated:
  1. Angular Loss: Standard $\arccos(\cos \theta)$ with a clamped input to avoid derivative divergence.
  2. Clamped Angular Loss: Uses a "straight-through" clamp in the backward pass to allow gradient flow even when inputs are clamped.
  3. Combined Angular–vMF Loss: Adds a von Mises–Fisher distribution term to learn a concentration parameter ( $\kappa$ ), providing calibrated directional uncertainties.
- The model was trained using Adam ( $5 \times 10^{-5}$ learning rate) with a batch size of 500 and dropout of 0.1.

Key Results

Performance: The ResNet-18 model trained on neutrino fingerprints achieved a Mean Angular Error (MAE) of 1.10 radians on the Kaggle test set.
Comparison: This result is approximately 0.15 radians higher than the top-performing solutions in the Kaggle competition (which utilized ensembles of GNNs and Transformers and achieved $\approx 0.95$ rad).
Efficiency: The model achieves this performance without ensembling, learning rate schedules, cosine restarts, or data augmentation, utilizing a parameter count of ~11.2 million, which is lower than the number of training examples.

Significance and Claims
The paper positions its contribution not as a new state-of-the-art (SOTA) in raw accuracy, but as a methodological demonstration of the viability of CNNs for IceCube reconstruction when paired with appropriate encoding.

Baseline Establishment: The work establishes a clean, interpretable, and efficient convolutional baseline. It demonstrates that with a deterministic event-to-RGB encoding, a straightforward CNN can rival more complex architectures (GNNs/Transformers) to within $\sim 0.15$ rad of the best competition entries.
Interpretability: Unlike black-box graph models, the fingerprint representation is intrinsically interpretable: each pixel maps directly to a physical detector, allowing for straightforward diagnostics of network predictions.
Future Directions: The authors suggest that the gap to SOTA can likely be closed without abandoning the simplicity of the approach by:
1. Improving encodings to better respect physical locality (e.g., space-filling curves).
2. Implementing modest architectural upgrades (e.g., depthwise-separable blocks).
3. Refining loss formulations based on the von Mises–Fisher distribution.

In conclusion, the paper argues that CNNs are not obsolete for IceCube-like tasks; rather, the "neutrino fingerprint" encoding provides a solid reference point that balances efficiency, interpretability, and competitive performance.