⚛️ high-energy experiments

AlphaHits: Full-Event Tracking and Reconstruction Towards a Hit-Level Foundation Model

The paper introduces AlphaHits, a Transformer-based foundation model that performs scalable, inclusive full-event charged-particle tracking and multi-task reconstruction directly from low-level detector hits, achieving state-of-the-art TrackML scores and performance comparable to high-level baselines for tasks like Higgs classification and jet reconstruction.

Original author: Sascha Caron, Nadezhda Dobreva, Polina Moskvitina, Eugene Shalugin, Javad Sohrabi, Roberto Ruiz, Yue Zhao

Published 2026-11-11

📖 6 min read🧠 Deep dive

CC BY 4.0

Original author: Sascha Caron, Nadezhda Dobreva, Polina Moskvitina, Eugene Shalugin, Javad Sohrabi, Roberto Ruiz, Yue Zhao

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 author. For technical accuracy, refer to the original paper. Read full disclaimer

At the Large Hadron Collider, protons smash together at nearly the speed of light, creating a chaotic spray of new particles that fly out in every direction. To understand what happened in these collisions, physicists must reconstruct the paths of these particles from the raw signals they leave behind in giant detectors. Traditionally, this has been a multi-step process: first, algorithms find the tiny points of impact, called hits; then, other programs connect these dots into lines called tracks; finally, physicists use those tracks to build up larger objects like jets or to classify the entire event. This chain of specialized tools works well for the most energetic particles, but it often discards the vast majority of the debris—the slower, lighter particles that are too faint to catch or too numerous to sort through individually. Because these low-energy particles make up more than ninety percent of the charged matter in a collision, ignoring them means throwing away most of the story.

A team of researchers has now developed a new approach that skips the traditional assembly line. Instead of building a hierarchy of objects step-by-step, they created a single, flexible system that learns to understand the entire event directly from the raw hits. By training a sophisticated computer model on millions of simulated collisions, they taught it to recognize patterns in the detector data without first filtering out the difficult, low-energy particles. This method, which they call AlphaHits, successfully reconstructs the paths of nearly every charged particle in a collision, including those moving very slowly, and uses that same understanding to identify complex event types and measure energy levels. The result is a system that sees the whole picture at once, rather than trying to piece it together from fragments, offering a more complete and efficient way to study the fundamental building blocks of the universe.

The core of this work is a model designed to handle the sheer volume of data produced in a single collision. In a typical high-energy event, the detector records up to 150,000 individual points of contact. Previous machine-learning attempts often focused only on the most energetic particles, effectively ignoring the dense cloud of slower ones that surrounds them. The researchers wanted to know if a computer could learn to navigate this entire cloud at once. They built a system that takes every single hit as an input and asks it to do two things simultaneously: figure out which hits belong to the same particle, and determine what kind of event occurred. To do this, they used a type of neural network architecture that can look at all the data points together, finding connections between them even when they are far apart in the detector.

In the first part of their study, the team focused on the task of tracking. They trained their model on a dataset of simulated collisions containing up to 150,000 hits, representing the crowded conditions expected in future high-luminosity runs of the collider. The model had to assign each hit to a specific particle trajectory without being told to ignore any particles based on their speed. This was a massive challenge because the low-speed particles create a tangled web of paths that are difficult to untangle. The researchers designed a two-stage process to solve this. First, a global view of the event helps the model make a rough guess about which hits belong together. Then, a local refinement stage zooms in on the most confusing areas to sort out the remaining ambiguities. This approach allowed the system to reconstruct the full content of the event, including the elusive low-speed particles that previous methods often missed. When tested, the model correctly identified the paths of particles across the entire range of speeds, achieving a level of accuracy that sets a new benchmark for inclusive tracking.

Building on this success, the researchers extended the system to perform multiple tasks at once. They took the same model that had learned to track particles and added extra "heads" that could interpret the data for different purposes. Now, the system could not only draw the tracks but also identify jets of particles, determine the type of particles within those jets, measure the total energy of the event, and even classify the event as a specific type of collision, such as one producing a Higgs boson. Remarkably, the model learned all these skills from the same underlying representation of the detector hits. It did not need separate programs for tracking, energy measurement, or classification; it used a single, shared understanding of the raw data to answer all these questions.

The results showed that this unified approach is highly effective. When asked to distinguish between collisions that produce a Higgs boson and those that do not, the model achieved a high level of accuracy using only the raw hits from the inner tracker. When the researchers added information from the calorimeter, which measures energy, the accuracy improved even further, matching or exceeding the performance of traditional methods that rely on fully reconstructed objects. The system also proved capable of reconstructing jets and measuring missing energy with precision comparable to established tools, all while processing the raw data directly. This suggests that the model learned a deep, physical understanding of the collision that is not dependent on the specific steps of the traditional reconstruction chain.

The study demonstrates that it is possible to move away from the old, fragmented way of analyzing particle collisions. By training a single system to look at the entire event from the very beginning, the researchers have shown that the raw data contains enough information to solve complex physics problems without intermediate filtering. This approach preserves information that would otherwise be lost, particularly from the low-energy particles that make up the bulk of the collision debris. While the current work relies on simulated data, the success of the model in handling such large and complex events suggests a promising path forward. It points toward a future where physics analyses can be optimized end-to-end, learning directly from the detector to uncover signals that might be hidden in the noise of conventional methods. The work does not claim to have solved every problem in particle physics, but it provides a powerful new tool that could fundamentally change how scientists extract knowledge from the chaotic beauty of high-energy collisions.

Technical Summary: AlphaHits – Full-Event Tracking and Reconstruction Towards a Hit-Level Foundation Model

Problem Statement

Traditional particle reconstruction at the Large Hadron Collider (LHC) relies on a sequential chain of specialized algorithms that transform low-level detector measurements into high-level physics objects (tracks, jets, vertices) before event-level inference. Current machine learning approaches often replace individual components of this chain but typically restrict reconstruction to high transverse momentum ( $p_T$ ) particles (e.g., $p_T \gtrsim 1$ GeV). Such thresholds exclude over 90% of the charged-particle population, discarding valuable information and simplifying the combinatorial problem artificially. Furthermore, existing "foundation models" in high-energy physics have predominantly relied on reconstructed, high-level objects rather than raw detector data.

This work addresses the challenge of constructing a learned representation directly from the full detector event, retaining information from the complete charged-particle population (including the dense, low- $p_T$ regime) without imposing $p_T$ selection thresholds. It further investigates whether such hit-level representations can support multi-task learning, simultaneously performing tracking, jet reconstruction, and event classification.

Methodology

The authors introduce AlphaHits, a Transformer-based framework building upon the architectures of TrackFormer and HiggsFormer. The approach is divided into two primary components:

1. AlphaHits-TrackFormer (Full-Event Tracking)

This component targets the reconstruction of all reconstructable charged particles in events containing up to $1.5 \times 10^5$ hits, simulating High-Luminosity LHC (HL-LHC) pileup conditions ( $\langle\mu\rangle = 200$ ).

Architecture: It employs a hierarchical pipeline:
- Sparse Attention: A learned Router assigns hits to overlapping logical groups based on radial position, pseudorapidity ( $\eta$ ), and azimuth ( $\phi$ ), enabling computationally tractable sparse attention (using FlexAttention) on events with $O(10^5)$ hits.
- Global Tracker: An 18-layer Transformer encoder predicts a discrete track token (binned $p_T, \eta, \phi$ ), signal probability, charge, and continuous track parameters for every hit.
- Local Refinement: A deterministic, charge-aware preconditioner splits/merges candidates. A learned Gate selects ambiguous regions for a local Refiner (a 32-slot Transformer) to resolve residual combinatorial ambiguities via Hungarian matching.
Training: The model is trained on the TrackML dataset ( $t\bar{t}$ events) using a multi-task loss combining discrete token prediction, continuous regression, and charge classification.

2. AlphaHits (Multi-Task Event Reconstruction)

Building on the TrackFormer backbone, this model extends the approach to a unified, multi-task framework.

Architecture: The backbone is first pre-trained on tracking tasks alone (Stage 1). It is then jointly fine-tuned (Stage 2) with nine distinct heads:
- Event-level: Classification ( $t\bar{t}H$ vs. $t\bar{t}$ ), scalar regression ( $H_T$ , $E_T^{miss}$ ), and lepton counting.
- Set-level: Jet reconstruction (up to 12 jets) with flavor tagging ($b, c, light$).
- Per-hit: Tracking tokens, particle kinematics, and jet membership.
Inputs: The model operates directly on raw detector hits (pixel and strip). For the calorimeter variant, Delphes-simulated calorimeter towers are added as auxiliary inputs.
Training Strategy: A two-stage curriculum is used. Stage 1 trains the backbone on tracking. Stage 2 performs joint fine-tuning using a geometric mean loss for main tasks (scale-free) and fixed-weight auxiliary terms.

Key Results

Tracking Performance

AlphaHits-TrackFormer achieves a TrackML score of 0.959 (inclusive over all reconstructable tracks, $p_T > 0.15$ GeV) on the test set. This represents 100% of the theoretical codebook ceiling (0.9588) and is the highest reported score for full-detector, inclusive reconstruction.
The model successfully reconstructs tracks down to $p_T \approx 150$ MeV, a regime where traditional algorithms often fail or are excluded.
Ablation: Joint training from scratch (without Stage 1 pre-training) yields a significantly lower score (0.446), confirming that pre-training on tracking is essential for the architecture's success.

Multi-Task and Classification Performance

Higgs Classification: On the $t\bar{t}H (H \to b\bar{b})$ vs. $t\bar{t}$ task, AlphaHits achieves an AUC of 0.932 using only tracker hits. When calorimeter towers are included, the AUC rises to 0.944.
Baseline Comparison: These results are comparable to or exceed a Particle Transformer (ParT) baseline trained on fully reconstructed Delphes objects (AUC 0.877 for tracker-only, 0.924 for tracker+calorimeter).
Jet Reconstruction: AlphaHits finds 83.0% of truth jets with a 2.0% fake rate using only hits (vs. 61.7% for Delphes tracker-only). With calorimeter inputs, it reaches 86.4% efficiency with a 1.5% fake rate, comparable to the full Delphes chain (86.7% efficiency).
Kinematic Regression: The model predicts $H_T$ and $E_T^{miss}$ with median residuals of 49 GeV and 20 GeV respectively (hits only), significantly outperforming tracker-only baselines which miss neutral energy contributions.

Significance and Claims

The paper posits that AlphaHits represents a significant step toward hit-level foundation models for collider physics. The key claims are:

Scalability: The architecture successfully scales to full HL-LHC event sizes ( $10^5$ hits) without restricting the particle population to high- $p_T$ subsets.
Unified Representation: A shared hit-level representation can effectively support diverse tasks (tracking, jet reconstruction, flavor tagging, and event classification) simultaneously, reducing the reliance on sequential, specialized algorithms.
Information Retention: By processing raw hits directly, the model retains information from low- $p_T$ particles and neutral energy deposits (via calorimeter inputs) that are typically discarded or approximated in standard reconstruction chains.
Foundation Model Paradigm: The work demonstrates that pre-training on a fundamental task (tracking) enables the transfer of representations to higher-level inference tasks, aligning with the broader vision of Large Physics Models.

The authors note that while the current multi-task model is evaluated on pileup-free events, the framework is designed to handle the complexity of full events. They acknowledge that further work is needed to optimize inference latency and to validate generalization across different detector configurations and physics processes.