Real-time lepton identification at LHCb in Run 3 using Lipschitz neural networks

Technical Summary: Real-time Lepton Identification at LHCb Run 3 Using Lipschitz Neural Networks

Problem Statement
The LHCb experiment at the Large Hadron Collider (LHC) has transitioned to a fully software-based trigger system for Run 3, operating with a "triggerless" readout architecture. This system processes the complete detector readout at the 40 MHz bunch-crossing rate, resulting in an input rate of approximately 30 MHz of inelastic proton–proton collisions to the High-Level Trigger (HLT). The first stage of this trigger (HLT1) executes on a large GPU farm and must reduce the event rate to O(1 MHz) in real time.

A critical challenge in this environment is the efficient identification of leptons (muons and electrons), which are key signatures for heavy-flavor and exotic decay processes. Traditional trigger-level particle identification (PID) relies on simple cut-based selections on reconstructed features. While robust and computationally inexpensive, these methods lack the discrimination power of machine learning. However, deploying complex machine learning models in HLT1 is constrained by strict requirements on throughput, memory footprint, and the need for robustness against variations in detector conditions and input features. The goal is to develop algorithms that offer improved background rejection and signal efficiency without compromising the real-time performance of the GPU-based trigger.

Methodology
The authors propose the use of Lipschitz-constrained neural networks for muon and electron identification within the HLT1 stage. The methodology is defined by the following components:

• Lipschitz Constraints: To ensure robustness and stability in a real-time environment, the neural networks are explicitly constrained to bound the sensitivity of the output to variations in the input features. For a network $f$ with Lipschitz constant $K$, the condition $\|f(x) - f(x')\| \le K\|x - x'\|$ is enforced. This prevents small perturbations in input features from causing disproportionately large changes in the network output, a crucial property for handling evolving detector conditions.
• Network Architecture:
  • Muon Identification: A fully connected feed-forward network with five layers of width 10.
  • Electron Identification: A shallower network with four layers of width 12, chosen as an empirical trade-off between classification performance and inference timing.
  • Implementation Details: The networks utilize GroupSort activation functions and a weight-normalization scheme (bounding individual weights in the first layer and the sum of absolute weights in subsequent layers) to maintain the Lipschitz property. All input features are rescaled to $[0, 1]$ prior to training.
• Input Features:
  • Muons: The network utilizes the $\chi^2_{Corr}$ matching operator (quantifying track-muon hit compatibility with multiple scattering), the $D^2$ variable (sum of squared residuals), and differences in track slopes ($\Delta t_x, \Delta t_y$) measured between the Scintillating Fiber (SciFi) tracker, the Vertex Locator (VELO), and the muon system.
  • Electrons: The network combines observables from the electromagnetic calorimeter (ECAL), including the energy-over-momentum ratio ($E/p$), the squared distance between the extrapolated track and the cluster barycenter ($\Delta^2_b$), and transverse shower-shape variables (second moments of the energy distribution).
• Training and Deployment: Models are trained offline using simulated events generated with Pythia, EvtGen, Photos, and Geant4. Signal classes consist of muons or electrons from $J/\psi$ and $\Upsilon(1S)$ decays, while background classes are composed of stable hadrons (protons for muon ID; pions and kaons for electron ID). The trained models are implemented as GPU kernels within the Allen framework, processing tracks in a batched manner to maximize GPU occupancy.

Key Contributions

1. Algorithm Development: The paper presents the first deployment of Lipschitz-constrained neural networks for real-time lepton identification in the LHCb Run 3 trigger.
2. Architecture Optimization: The authors demonstrate that shallow, fully connected networks (4–5 layers) can achieve high discrimination power while remaining compatible with the stringent memory and throughput constraints of the HLT1 GPU environment.
3. Robustness via Constraints: By explicitly bounding the Lipschitz constant, the authors provide a mechanism to ensure controlled model behavior, addressing the specific need for stability in real-time triggers where input distributions may differ slightly from training data.
4. Integration: The algorithms are integrated into the Allen framework, processing large collections of tracks simultaneously with minimal impact on the overall HLT1 throughput.

Results
The performance of the Lipschitz-constrained networks is evaluated using simulated data and compared against the baseline cut-based PID algorithms:

• Muon Identification: The neural network achieves substantial gains in background rejection (specifically pion rejection) for moderate-to-high momentum tracks, which constitute the majority of tracks passing kinematic pre-selection. For low-momentum muons, performance is comparable to the baseline. This enhanced rejection is essential for maintaining manageable trigger output rates while preserving high efficiency for heavy-flavor decays.
• Electron Identification: The network provides robust discrimination across the full kinematic range. Improvements over the cut-based baseline are most pronounced at low momentum, where the ECAL energy resolution is poorer and single-variable discrimination (like $E/p$) is weaker. The network exhibits nearly uniform performance across pseudorapidity and transverse momentum ($p_T$), adapting naturally to different physical regimes by combining track-cluster matching, shower shape, and energy measurements.
• Resource Efficiency: The networks are highly compact, requiring only approximately 500 parameters (about 2 kB in single precision) and adding only 24–28 bytes of data per track to the buffer. Profiling indicates that the network kernels consume approximately 0.5–0.9% of the total GPU processing time, which is less than the legacy cut-based PID operators they complement.

Significance and Claims
The paper claims that Lipschitz-constrained neural networks offer a robust and efficient improvement over existing trigger-level PID methods. The significance lies in demonstrating that machine learning can be successfully integrated into critical online systems with high data rates, provided that model complexity and behavior are carefully constrained.

The authors state that while the results presented are based on simulated data, the algorithms have been deployed and validated within the HLT1 trigger and are running stably in production. The work illustrates the potential of carefully constrained machine learning models for real-time decision-making in high-energy physics, balancing the need for high performance with the reliability required for operational triggers. The techniques developed are noted as potentially relevant to other real-time decision-making problems in high-energy physics and beyond.