Hits to Higgs: Hit-Level Higgs Classification from Raw LHC Detector Data Using Higgsformer

The paper introduces Higgsformer, a transformer-based model that successfully classifies $t\bar{t}H$ versus $t\bar{t}$ events directly from raw inner tracker hits, achieving performance comparable to traditional object-based reconstruction pipelines while bypassing intermediate physics object reconstruction.

The Gist

Imagine the Large Hadron Collider (LHC) as the world's most powerful, high-speed camera. Every second, it takes 40 million "photos" of protons smashing into each other. These collisions create a chaotic explosion of tiny particles, leaving behind a trail of digital footprints called hits on the detector's inner sensors.

Traditionally, physicists have acted like detectives who first have to clean up the crime scene before solving the case. They take those millions of raw footprints, painstakingly reconstruct them into recognizable objects (like "jets" or "tracks"), and then use those objects to figure out what happened.

This paper introduces a new detective: Higgsformer. Instead of cleaning up the crime scene first, Higgsformer looks at the raw, messy pile of footprints and tries to solve the mystery immediately.

The Mystery: Finding a Needle in a Haystack

The specific mystery the team is trying to solve is finding the Higgs boson.

• The Background Noise: Most collisions create a common event called $t\bar{t}$ (top quark pairs). It's like a busy street with lots of cars.
• The Signal: Sometimes, a Higgs boson is created along with those top quarks ($t\bar{t}H$). The Higgs quickly decays into two "bottom" quarks.
• The Challenge: The Higgs event looks almost exactly like the background noise. It's like trying to spot a specific red car in a sea of red cars, where the only difference is that the red car has a tiny, invisible sticker on it.

The Two Approaches

1. The Old Way: The "Reconstruction Pipeline" (Delphes & ParT)

Think of this as the traditional chef.

• Step 1: The chef takes raw ingredients (the detector hits).
• Step 2: They chop, wash, and cook them into recognizable dishes (reconstructed particles like jets and tracks).
• Step 3: They taste the dishes to decide if it's a "Higgs meal" or a "background meal."
• The Problem: In the cooking process, some of the subtle, unique flavors (low-level information) might get lost or altered. Also, the chef has to follow strict recipes (algorithms) that might introduce bias.

2. The New Way: Higgsformer (The "AI Chef")

Think of this as a super-intelligent AI that skips the cooking.

• The Input: It looks directly at the raw, uncooked ingredients (the raw hits on the sensor).
• The Magic: It uses a Transformer (the same type of AI architecture that powers tools like ChatGPT). Instead of reading words, it reads the spatial patterns of the hits.
• The Analogy: Imagine you are trying to guess what a song is.
  • The Old Way asks you to listen to the song, write down the sheet music (notes, tempo, key), and then guess the genre based on the sheet music.
  • Higgsformer just listens to the raw sound waves and guesses the genre instantly, noticing subtle vibrations in the audio that the sheet music might have missed.

How Did They Test It?

The researchers built a virtual simulation of the LHC detector. They fed the AI millions of collision events:

1. Higgsformer looked at the raw hits.
2. ParT (the old way) looked at the reconstructed objects.

They tested them under different conditions, including "pileup" (which is like adding more noise or traffic to the scene).

The Results: A Surprising Victory

• Speed: The AI is incredibly fast. While traditional methods take about 1 second to process one event, Higgsformer does it in milliseconds. It's like the difference between reading a book by hand and scanning it with a laser.
• Accuracy: Even though Higgsformer only looked at the raw hits from the inner tracker (ignoring other parts of the detector), it achieved a score (AUC) of 0.855.
• The Comparison: This score is almost as good as the traditional method, even though the traditional method had the advantage of "b-tagging" (a special tool to identify bottom quarks).
• The "Aha!" Moment: The researchers checked what the AI was looking at. They found that Higgsformer wasn't just counting the number of hits (a simple trick). It was actually learning to focus on the specific hits that came from the Higgs decay, ignoring the noise. It learned the "shape" of the Higgs event directly from the chaos.

Why Does This Matter?

This is a proof of concept. It shows that we might not need to spend years building complex, rigid reconstruction pipelines to find new physics.

• Less Bias: By skipping the "cooking" step, we avoid the biases of human-made algorithms.
• More Information: We use all the data, not just the parts we decided were important enough to keep.
• Future Potential: If this works in real life (not just simulations), future experiments could be faster, cheaper, and potentially discover things we would have missed with the old methods.

The Catch

The paper admits this is currently a simulation. Real-world data is messier than a computer simulation. Before Higgsformer can replace the traditional methods in a real lab, scientists need to make sure it doesn't get confused by the quirks of real hardware. But the door is now open: We can teach AI to see the universe directly, without a manual.

Technical Summary

1. Problem Statement

The Large Hadron Collider (LHC) generates massive volumes of raw detector data (hundreds of terabytes annually). Traditionally, this data undergoes a complex, multi-stage reconstruction pipeline (trajectory fitting, clustering, jet identification) to produce high-level physics objects (e.g., jets, leptons) before being used for analysis. This process introduces inductive biases and may discard low-level information critical for specific tasks.

The paper addresses the question: Can modern machine learning models classify physics events directly from raw detector hits, bypassing the entire reconstruction chain?

• Specific Task: Distinguishing signal events ($t\bar{t}H$ with $H \to b\bar{b}$) from the dominant background ($t\bar{t}$).
• Challenge: These events share similar final-state topologies, differing only subtly in object multiplicities and kinematics. The task is particularly difficult because the signal relies on identifying additional $b$-jets from the Higgs decay amidst the background.

2. Methodology

The authors propose a comparative study between two distinct pipelines using identical physics event generation (Pythia8) but different simulation and processing stages.

A. Data Generation & Simulation

• Signal/Background: Generated using Pythia8 for $t\bar{t}H$ ($H \to b\bar{b}$) and $t\bar{t}$ processes.
• Hit-Level Pipeline (Proposed):
  • Simulated using ACTS/Fatras (fast simulation) to generate "SimHits" (truth-level interactions).
  • Digitized to emulate realistic pixel/strip detector responses.
  • Output: Raw 3D coordinates $(x, y, z)$ of detector hits, tagged with volume/layer indices.
  • Pileup (PU): Evaluated at 0, 5, and 20 interactions per bunch crossing.
• Object-Level Pipeline (Baseline):
  • Simulated using Delphes (ATLAS card).
  • Reconstructed into high-level objects: Track-jets, $b$-tag discriminants, and track-based missing transverse momentum ($E_T^{miss}$).
  • Constraint: To ensure a fair comparison, the baseline uses only inner tracker information (no calorimeter/muon data), matching the input scope of the hit-level model.

B. Machine Learning Architectures

1. Higgsformer (Proposed Model):

   • Architecture: A lightweight, set-based Transformer adapted from the "Trackformer" (originally for hit-to-track assignment).
   • Input: Raw detector hits treated as tokens.
   • Variants:
     • Higgsformer-small: 2 encoder layers, 4 attention heads, hidden size $d=32$.
     • Higgsformer-big: 8 encoder layers, 8 attention heads, hidden size $d=128$. Includes an auxiliary $H_T$ (scalar sum of transverse momenta) regression head to encourage learning of physical features.
   • Mechanism: Uses FlashAttention/FlexAttention for efficiency. Aggregates hit representations via max pooling (or mean/CLS) into an event vector for binary classification.
   • Augmentation: Utilizes geometric symmetries ($\phi$-rotation, $z \to -z$ flip) to improve generalization.

2. Particle Transformer (ParT) (Baseline):

   • Architecture: A state-of-the-art object-level Transformer.
   • Input: Reconstructed track-jets and kinematic variables.
   • Configuration: Vanilla self-attention (no physics-informed extensions) to serve as a clean baseline.
   • Variables: Evaluated at three $b$-tagging working points (efficiencies of 40%, 60%, 80%).

3. Key Contributions

• First End-to-End Hit-Level Classification: This is the first study to demonstrate that a Transformer model can classify $t\bar{t}H$ vs. $t\bar{t}$ events directly from raw inner tracker hits without any intermediate reconstruction or handcrafted features.
• Architecture Adaptation: Successfully repurposed a hit-to-track assignment model (Trackformer) for high-level event classification (Higgsformer).
• Fair Benchmarking: Established a rigorous comparison framework where both models operate under identical detector constraints (inner tracker only) and physics generation, isolating the impact of the input representation (hits vs. objects).
• Feature Interpretability: Demonstrated that the model learns physically meaningful structures rather than relying on simple proxies like total hit counts.

4. Results

Performance Metrics (AUC)

• Hit-Level vs. Object-Level:
  • Higgsformer-big achieved an AUC of 0.855 (at 0 pileup) using only raw hits.
  • This performance matches the ParT baseline trained on reconstructed objects at a $b$-tagging efficiency of ~40%.
  • While ParT performs better at higher $b$-tagging efficiencies (e.g., 80% WP $\to$ AUC 0.95), the hit-level model achieves comparable discrimination without explicit $b$-tagging algorithms.
• Scaling Laws:
  • Higgsformer performance improves monotonically with dataset size (10k $\to$ 40k events), whereas the object-based ParT model shows signs of saturation.
  • Geometric Augmentation consistently improved Higgsformer-small performance by $\approx$ 0.016–0.019 AUC.
• Robustness to Pileup:
  • Performance degrades with increasing pileup (PU 20 AUC $\approx$ 0.654 for small model), but remains significantly above random chance.
  • A baseline classifier using only "number of hits" ($n_{hits}$) collapses rapidly under pileup, proving Higgsformer learns complex topological features, not just hit density.

Learned Features

• Hit Importance Analysis: Using a "leave-one-hit-out" method, the authors found that hits originating from Higgs decay products ($b$-quarks) are assigned systematically higher importance scores than background hits.
• Symmetry Learning: Visualization of top-10 important hits shows the model progressively learns the cylindrical symmetry of the detector and the specific kinematic structures of the Higgs decay as training data increases.

Efficiency

• Speed: Higgsformer inference is extremely fast.
  • Higgsformer-small: < 2 ms per event (NVIDIA A100).
  • Higgsformer-big: < 10 ms per event.
  • This represents a speedup of several orders of magnitude compared to traditional CPU-based tracking (~1 s per event).

5. Significance and Future Outlook

• Paradigm Shift: The work validates the potential of end-to-end learning in High Energy Physics (HEP), suggesting that deep learning can extract discriminative power directly from raw sensor data, potentially simplifying the analysis chain and reducing information loss.
• Proof of Concept: While currently a simulation-based study, it establishes that hit-level classifiers can rival traditional object-based approaches for specific tasks.
• Limitations & Next Steps:
  • The study is simulation-based; real-world deployment requires addressing data-simulation mismatches and integrating with calibration workflows.
  • Future work will focus on scaling to larger datasets, incorporating full detector systems (calorimeters, muons), and testing in high-pileup environments typical of the High-Luminosity LHC.

Conclusion: The paper successfully demonstrates that Transformer-based architectures can bypass traditional reconstruction pipelines to classify complex Higgs events directly from raw detector hits, achieving competitive performance with significantly reduced latency and a more direct connection to raw sensor data.