On-chip probabilistic inference for charged-particle tracking at the sensor edge

This paper demonstrates that embedding neural networks in the front-end electronics of silicon particle detectors enables efficient, low-latency probabilistic inference of charged-particle kinematics directly at the sensor edge, addressing the critical bandwidth and power constraints of modern high-rate scientific instruments.

The Gist

Imagine you are trying to watch a high-speed car race, but your camera is so overwhelmed by the sheer number of cars that it can only record a tiny, blurry snapshot of the track every second. You miss the details of who is winning, how fast they are going, or even which direction they are turning.

This is the exact problem facing scientists at the Large Hadron Collider (LHC).

The Problem: Too Much Data, Too Little Time

The LHC smashes particles together billions of times a second. The sensors (like giant, ultra-sensitive digital cameras) surrounding the collision point generate a massive flood of data—petabytes every second.

However, the computers trying to save this data have a "bandwidth bottleneck." It's like trying to pour a firehose of water into a drinking straw. To prevent the system from drowning, the current "filters" (called triggers) have to throw away 99.9% of the data immediately, keeping only the most obvious collisions. This means scientists might be missing subtle, rare, and exciting discoveries because the data was discarded before anyone could look at it.

The Solution: A "Smart" Camera Chip

The authors of this paper propose a radical new idea: Don't just take a picture; understand the picture instantly.

Instead of sending raw, messy data to a computer to be analyzed later, they are embedding a tiny, super-smart "brain" (a neural network) directly onto the sensor chip itself. This is called On-Chip Probabilistic Inference.

Think of it like upgrading a security camera:

• Old Way: The camera records 24 hours of grainy video and sends it all to a guard room. The guard has to watch it all to find a burglar.
• New Way: The camera has a tiny AI inside it. It watches the video, realizes, "Oh, that's just a cat walking by, ignore it," but if it sees a person running, it instantly says, "Burglar! Here is their location, speed, and direction!" and sends only that summary to the guard.

How It Works: The "Smart Pixel"

The researchers trained these tiny AI brains to look at the "footprints" left by charged particles as they pass through a single layer of silicon.

1. The Footprint: When a particle hits the sensor, it leaves a pattern of electrical charge (like a splash of water).
2. The Brain: The AI looks at this splash and instantly calculates:
   • Where did it hit? (Position)
   • How fast was it moving? (Angle)
   • How sure are we about these numbers? (Uncertainty)
3. The Output: Instead of sending the whole messy splash data, the chip sends a tiny, clean summary: "Particle hit at X, moving at Y degrees."

The Magic Tricks They Used

To make this work on a tiny chip with very limited power and space, the team had to be incredibly clever:

• The "Soft" Translator: Usually, sensors turn analog signals (smooth waves) into digital numbers (0s and 1s) using fixed rules. The team taught the AI to learn the best rules for this translation itself. It's like teaching a translator to find the perfect words to convey a feeling, rather than using a fixed dictionary.
• The "Tiny" Brain: They shrunk the AI down so it fits on a chip no bigger than a fingernail. They used a technique called "quantization," which is like taking a high-definition photo and compressing it into a low-resolution JPEG. Surprisingly, the AI still understood the picture perfectly, even with the lower resolution.
• Speed: The chip is so fast it can make a decision in the time it takes for a particle to cross the sensor (nanoseconds). It's fast enough to keep up with the 40 million collisions happening every second.

Why This Matters

This isn't just about saving space; it's about unlocking new science.

By processing data right at the source (the "edge"), they can reduce the amount of data sent to the main computers by a factor of 10. This means:

• More Data Saved: They can keep the "good stuff" they used to throw away.
• Better Triggers: The system can make smarter decisions in real-time about which collisions are worth saving.
• Future-Proof: This technology can be used in space telescopes, medical imaging, or any place where you need to make smart decisions instantly with limited power.

The Bottom Line

The researchers successfully built a "smart sensor" that doesn't just see the world; it understands it instantly. They proved that you can put a sophisticated AI brain directly onto a silicon chip, making it fast, small, and energy-efficient. This opens the door to a new generation of scientific instruments that are "intelligent" from the very first moment they detect a particle.

Technical Summary

1. Problem Statement

Modern high-energy physics (HEP) experiments, such as the Large Hadron Collider (LHC) and its High-Luminosity upgrade (HL-LHC), face extreme constraints on bandwidth, latency, and power.

• Data Overload: Silicon pixel trackers generate petabytes of data per second. The sheer volume of data (O(2 billion channels for HL-LHC) at 40 MHz collision rates) far exceeds the bandwidth available for real-time transfer and analysis.
• Current Limitations: Real-time trigger systems currently discard most pixel detector data because they cannot process it fast enough. Consequently, the most granular information (from the innermost pixel layers) is inaccessible for real-time decision-making.
• The Challenge: There is a need to reduce the raw charge information from pixel sensors into a compact set of kinematic variables (position and angle) directly at the sensor edge ("smart pixels") without sacrificing reconstruction accuracy, while adhering to strict area, power, and latency constraints of Application-Specific Integrated Circuits (ASICs).

2. Methodology

The authors propose embedding neural networks (NNs) directly into the front-end readout chip (ASIC) to perform probabilistic inference on ionization patterns.

A. Dataset and Simulation

• Simulation: Charged pions traversing a simulated high-resistivity silicon sensor ($16 \times 16$ pixels, $50 \times 12.5 \, \mu m^2$ pitch, $100 \, \mu m$ thickness) in a 3.8 T magnetic field.
• Inputs: 2D arrays of collected charge over time. Two temporal resolutions were tested: 20 time frames (200 ps intervals) for ideal performance, and 2 time frames (3.8 ns intervals) for realistic ASIC constraints.
• Outputs: Regression of kinematic parameters: hit position ($x, y$), polar incident angle ($\alpha$), and azimuthal incident angle ($\beta$).

B. Neural Network Architectures

Three architectures were tested to balance physics performance and hardware resource usage:

1. Conv2D: Uses depthwise-separable convolutions to extract spatial features from 2D charge images, followed by pooling and dense layers.
2. Conv1D: Projects 2D charge data into 1D $x$ and $y$ profiles via average pooling, processes them with 1D convolutions, and concatenates them.
3. MLP (Multi-Layer Perceptron): Replaces convolutional layers with a lightweight projection stage (flattening and dense layers) followed by a fully connected regression block.

C. Model Variants

Models were trained to output different levels of information:

• Max: Predicts $x, y, \cot\alpha, \cot\beta$ and the full covariance matrix (14 outputs).
• Full: Predicts $x, y, \cot\alpha, \cot\beta$ and individual uncertainties ($\sigma$) for each (8 outputs).
• Slim: Predicts only $x, y, \cot\beta$ (3 outputs), optimized for minimal bandwidth.

D. End-to-End Training & Digitization

• SoftQuantize: The analog front-end converts charge to a 2-bit digital signal. Instead of using fixed thresholds, the authors implemented a SoftQuantize layer using a differentiable Straight-Through Estimator (STE). This allows the network to jointly learn the optimal ADC thresholds and the regression weights during training, shifting digitization from a fixed engineering choice to a learned component.
• Quantization-Aware Training (QAT): Models were trained with fixed-point precision (using QKeras) to simulate hardware constraints before synthesis.

E. Hardware Synthesis

• Workflow: TensorFlow/Keras $\to$ QKeras (quantization) $\to$ hls4ml (C++ translation) $\to$ Siemens Catapult HLS.
• Target: TSMC 28 nm CMOS process with a 25 ns clock period.
• Precision: Weights/biases quantized to fixed<4,1> for conv layers and fixed<8,1> for dense layers.

3. Key Contributions

1. First On-Sensor Probabilistic Inference: Demonstrates the feasibility of regressing charged-particle kinematic parameters and their uncertainties directly from a single silicon layer using embedded ML.
2. Joint Optimization of Digitization and Inference: Introduces a method to learn optimal ADC thresholds alongside network weights, optimizing the entire signal chain for physics performance rather than treating digitization as a static pre-processing step.
3. Hardware-Physics Co-Design: Successfully synthesizes compact neural networks (Conv2D, Conv1D, MLP) that meet strict LHC constraints (latency $\le$ 2 clock cycles, low area) while maintaining high physics accuracy.
4. Superiority Over Traditional Methods: Shows that a simple on-chip ML model trained on a single layer outperforms complex, offline non-ML reconstruction algorithms that rely on multiple layers and "optimistic" assumptions (e.g., perfect knowledge of external track parameters).

4. Results

• Performance vs. Constraints:
  • Reducing input from 20 time frames to 2 caused a 30–40% degradation in resolution, highlighting the importance of time evolution.
  • 2-bit digitization and 8-bit network quantization introduced only minor losses (5–10% resolution degradation) compared to floating-point, electron-level precision.
• Comparison with Non-ML Methods:
  • The MLP Full model (on-chip, 2-bit input) achieved $x$ and $y$ position resolution comparable to the offline LocalReco algorithm (which uses multiple layers and perfect $\alpha$ knowledge).
  • The ML model significantly outperformed the Barycenter method and the Geometric method for angle reconstruction ($\alpha, \beta$), even when the Geometric method assumed perfect knowledge of Lorentz drift and sign conventions.
  • The ML model reduced bias in the $y$ parameter significantly compared to non-ML methods.
• Hardware Metrics:
  • Latency: All designs achieved 2 clock cycles latency with an initiation interval of 1 cycle.
  • Timing: Met the 25 ns constraint with 57–66% timing slack.
  • Area: The most compact models (MLP variants) occupied only 0.30–0.34 mm².
  • Bandwidth Reduction: The approach reduces the data rate required to read out pixel sensors by a factor of 10 (from ~72 Gbps to ~5.8 Gbps per sensor) by outputting kinematic variables instead of raw pixel data.

5. Significance

• Unlocking Pixel Detectors for Triggers: This work enables the use of high-granularity pixel data in real-time Level-1 triggers, which was previously impossible due to bandwidth limits. This could drastically improve trigger efficiency and physics reach for the HL-LHC.
• Intelligent Sensing Paradigm: It establishes a new regime for "intelligent sensing" where probabilistic inference and uncertainty quantification occur at the extreme edge (sensor level), under severe resource constraints.
• Generalizability: The co-design workflow (ML + ASIC synthesis + digitization optimization) provides a template for other scientific instruments operating in extreme environments (cryogenic, space, high-radiation), where maximizing scientific return under fixed power/bandwidth budgets is critical.
• Validation of ML in HEP: It proves that ML can match or exceed traditional reconstruction algorithms even with limited input data (single layer, low precision), validating the shift toward ML-driven detector readout.