Enabling Low-Latency Machine learning on Radiation-Hard FPGAs with hls4ml

This paper demonstrates the first viable, ultra-fast machine learning application on radiation-hard FPGAs by developing a lightweight autoencoder for the PicoCal calorimeter and extending the hls4ml library with a new backend to synthesize the model for Microchip PolarFire devices, achieving a 25 ns latency with minimal resource usage.

The Gist

Imagine you are trying to listen to a conversation in a room that is absolutely deafeningly loud. The room is the Large Hadron Collider (LHC), a giant machine that smashes particles together to discover the secrets of the universe. Every second, it creates a tsunami of data—so much information that if you tried to send it all to a computer far away, the internet would crash, and you'd miss the most important moments.

To solve this, scientists want to put a "smart filter" right inside the machine, on the very sensors that catch the particles. This filter needs to be incredibly fast, incredibly small, and tough enough to survive the radioactive environment of the collider.

This paper is about building that filter using a special kind of computer chip called an FPGA (Field-Programmable Gate Array). Think of an FPGA as a Lego set for electronics: you can snap the pieces together to build a custom brain for a specific job.

Here is the story of how the authors built this system, broken down into three simple parts:

1. The Problem: Too Much Noise, Not Enough Time

The sensors (called PicoCal) catch a "pulse" of light every time a particle hits them. Originally, the sensor records this pulse as a long list of 32 numbers (like a detailed drawing of a wave).

• The Challenge: The machine produces these pulses 40 million times a second. Sending all 32 numbers for every pulse is impossible; the wires would get clogged.
• The Goal: Compress those 32 numbers down to just two numbers without losing the important story the wave is telling (like when the particle arrived and how strong it was).

2. The Solution: A "Smart Summarizer" (The Autoencoder)

The team built a tiny Artificial Intelligence (AI) model called an Autoencoder.

• The Analogy: Imagine you have a 32-page comic book describing a superhero's fight. You need to send a summary to a friend, but you can only write two sentences.
• How it works: The AI looks at the 32-page comic (the 32 numbers) and learns to summarize it into two key sentences (the two numbers).
  • Sentence 1 tells you how big the fight was (the amplitude).
  • Sentence 2 tells you how the fight started (the shape/timing).
• The Magic: When they tried to rebuild the comic from just those two sentences, it looked almost exactly like the original! The AI didn't just throw away data; it learned the "essence" of the wave. Even better, by smoothing out the static noise in the process, the AI actually helped them pinpoint the exact time of the event better than looking at the raw, noisy data.

3. The Hardware: Making it "Radiation-Proof"

This is where the paper gets really cool. Most AI chips are like delicate glass figurines; if you put them in the radioactive tunnel of the LHC, the radiation would scramble their brains (flip their bits) and break them.

• The Old Way: To protect standard chips, you have to build three copies of every part and let them vote on the answer. This is like hiring three people to do one job just to be safe. It's slow and takes up a lot of space.
• The New Way: The authors used a special chip called Microchip PolarFire. Think of this chip as being made of "indestructible stone" instead of "glass." Its internal memory is naturally immune to radiation. It doesn't need the triple-voting system.
• The Result: Because the AI model was so tiny and efficient (thanks to a process called quantization, where they simplified the math from heavy decimals to simple whole numbers), it fit comfortably inside this "stone" chip. It used less than 3% of the chip's space, leaving plenty of room for other tasks.

The Big Breakthrough: The "Universal Translator"

Finally, the authors had to teach the AI how to talk to this specific "stone" chip.

• The Barrier: The standard tool scientists use to turn AI models into chip code (called hls4ml) didn't speak the language of these radiation-hard chips. It was like trying to use a French dictionary to translate a book into Japanese.
• The Fix: The team wrote a new "translator" (a software backend) that connects the AI directly to the radiation-hard chip.
• Why it matters: This isn't just about one experiment. They built a bridge that allows any scientist to easily put AI onto these tough, radiation-proof chips. It's like opening a new highway for future experiments in space, nuclear plants, and particle colliders.

The Bottom Line

The team successfully built a tiny, super-fast, radiation-proof AI that sits right on the sensor. It takes a complex signal, shrinks it down to two numbers, and sends it on its way in just 25 nanoseconds (that's 25 billionths of a second).

They proved that you don't need massive, fragile computers to do smart things in the most dangerous places on Earth. You just need a clever algorithm and the right kind of "indestructible" Lego set. This opens the door for the next generation of physics experiments to see the universe with sharper eyes and faster reflexes.

Technical Summary

1. Problem Statement

Future high-energy physics experiments, specifically the LHCb Upgrade II at the High-Luminosity Large Hadron Collider (HL-LHC), face unprecedented data rates (up to 200 Tb/s) and high pile-up conditions (approx. 40 simultaneous collisions). To manage this, the experiment plans to deploy the PicoCal, a high-granularity electromagnetic calorimeter with excellent timing capabilities.

• The Challenge: The PicoCal readout generates 32-sample pulse shapes (16-bit each) per channel. Transmitting this raw data to the backend is bandwidth-prohibitive. The data must be compressed on the detector (edge computing) into a maximum of two numbers per pulse while preserving critical physics information (timing, amplitude, and shape).
• The Constraints:
  • Latency: Processing must occur within 25 ns (4 clock cycles at a 160 MHz internal clock) to keep up with the 40 MHz bunch crossing rate.
  • Radiation Hardness: The electronics operate in a harsh radiation environment. Standard SRAM-based FPGAs require Triple Modular Redundancy (TMR) for protection, which triples resource usage. Flash-based FPGAs are preferred for their inherent immunity to configuration Single Event Upsets (SEUs).
  • Toolchain Gap: The standard High-Level Synthesis (HLS) tool for ML in High-Energy Physics (HEP), hls4ml, lacked support for radiation-hard Microchip (formerly Microsemi) PolarFire FPGAs, which use the SmartHLS compiler.

2. Methodology

The authors pursued a three-pronged approach: algorithm development, hardware-aware optimization, and toolchain extension.

A. Algorithm: Lightweight Autoencoder

• Architecture: A fully connected autoencoder was designed to compress the 32-dimensional input vector into a 2-dimensional latent space ($32 \to 2$).
  • Encoder (On-Detector): A single dense layer mapping 32 inputs to 2 latent variables, followed by a ReLU activation.
  • Decoder (Training Only): A mirror dense layer reconstructing the 32-sample pulse from the 2 latent variables.
• Training: The model was trained on Monte Carlo simulated data (Geant4) representing LHCb PicoCal conditions, including signal photons (0.5–5 GeV) and background pile-up.
• Objective: Minimize Mean Squared Error (MSE) while preserving the ability to reconstruct the pulse shape, specifically the rise time and peak amplitude.

B. Hardware-Aware Quantization

• Strategy: To fit the model into FPGA resources and reduce logic complexity, a mixed-precision fixed-point quantization scheme was applied.
  • Inputs/Activations: 16-bit fixed-point ($<16, 6>$).
  • Weights/Biases: Aggressively quantized to 10-bit fixed-point ($<10, 4>$).
• Rationale: A quantization scan showed that reconstruction performance (MSE) plateaued at 10 bits, offering near-full-precision accuracy with significantly reduced hardware footprint.

C. Toolchain Development: hls4ml Backend

• Innovation: The team developed a new backend for the hls4ml library to target the Microchip SmartHLS compiler.
• Implementation: This involved creating a manual C++ baseline, adapting C++ templates to use SmartHLS-native libraries and pragmas, and writing a new Python code-generation engine to map quantized tensors to hls::ap_fixpt types.
• Validation: Rigorous C-simulation ensured the new backend produced bit-for-bit identical results to established hls4ml flows.

3. Key Contributions

1. Validated ML Algorithm: Development and validation of a $32 \to 2$ autoencoder that effectively compresses calorimeter pulse shapes while preserving essential physics features (amplitude, rise time, and timing).
2. Hardware-Aware Optimization: Demonstration that the model can be reduced to 10-bit weights with negligible performance loss, enabling efficient implementation on resource-constrained FPGAs.
3. New hls4ml Backend: The creation of the first open-source backend for Microchip SmartHLS, bridging the gap between the HEP ML ecosystem and radiation-hard Flash-based FPGAs. This is the first time ML models have been automatically deployed to PolarFire FPGAs via hls4ml.

4. Results

Physics Performance

• Reconstruction: The autoencoder faithfully reconstructs pulse shapes. Visual comparison and low MSE values confirm preservation of global and fine-grained features.
• Latent Space Interpretability:
  • Latent variable $z_1$ correlates strongly with peak amplitude (Pearson $\approx 0.98$).
  • Latent variable $z_0$ captures secondary shape features and timing information.
• Timing Resolution: Applying a Constant Fraction Discriminator (CFD) to the reconstructed pulses yielded a 2x improvement in timing precision compared to the original 32-sample pulses (approx. 30 ps vs. 62 ps standard deviation). The autoencoder acts as a denoiser, smoothing the signal for better timestamp extraction.
• Rise Time: The model successfully restores fine temporal features lost during downsampling, achieving rise-time consistency within a few percent of the full-resolution (1024-sample) reference.

Hardware Synthesis (Microchip PolarFire MPF100T)

• Latency: Achieved 25 ns (4 clock cycles at 160 MHz), meeting the strict 40 MHz throughput requirement.
• Resource Utilization (Per Channel):
  • LUTs (Logic): 3,385 used (3.12% of available).
  • Math Blocks (DSP): 1 used (0.30% of available).
  • Memory: 0% utilization.
• Scalability: The design is lightweight enough to support 8 channels on a single FPGA (projected ~25% LUT usage), leaving ample resources for other control logic.
• Frequency: Post-synthesis analysis showed a maximum frequency ($F_{max}$) of 234 MHz, well above the 160 MHz target.

5. Significance and Impact

• Feasibility for LHCb Upgrade II: This work provides a "proof-of-principle" that ultra-low-latency, radiation-hard ML is viable for the PicoCal. The solution fits within the inherent radiation-hard logic of the FPGA, potentially avoiding the need for complex TMR schemes for the user logic.
• Democratizing Radiation-Hard ML: By integrating Microchip PolarFire support into hls4ml, the authors have removed a major barrier to entry. This allows the broader HEP community to deploy ML on Flash-based FPGAs without manual, bespoke HLS coding.
• Future Applications: The automated workflow enables rapid design space exploration (e.g., varying quantization) and paves the way for intelligent, on-detector data processing in future colliders and space-based applications.
• Holistic Radiation Hardness: The paper highlights a synergy between algorithmic efficiency (small model) and hardware robustness (Flash memory). Because the model is so small, it can reside in the FPGA's inherently protected configuration region, offering a robust solution without the overhead of full TMR.

In conclusion, this paper successfully demonstrates an end-to-end workflow for deploying a radiation-hard, ultra-fast ML data compression system on FPGAs, solving a critical bottleneck for next-generation particle physics experiments.