Real-time graph neural networks on FPGAs for the Belle II electromagnetic calorimeter

This paper presents the first implementation of a real-time Graph Neural Network on an FPGA for the Belle II electromagnetic calorimeter trigger, which achieves 8 MHz throughput with 3.168 μs latency while significantly improving position resolution, cluster purity, and efficiency compared to the baseline algorithm.

The Gist

Imagine you are trying to listen to a single, quiet conversation in the middle of a massive, roaring stadium during a thunderstorm. That is essentially what the Belle II experiment does. It smashes particles together at nearly the speed of light to study the secrets of the universe, but the resulting "noise" from the collision and the surrounding environment is overwhelming.

To make sense of this chaos, the experiment needs a trigger system—a super-fast bouncer that decides, in the blink of an eye, which events are worth saving and which are just background noise.

This paper describes a major upgrade to that bouncer for the Electromagnetic Calorimeter (a giant detector that measures the energy of particles like photons and electrons). They replaced an old, rigid rulebook with a Graph Neural Network (GNN) running on a specialized computer chip called an FPGA.

Here is the breakdown of how they did it, using simple analogies:

1. The Problem: The Old "Grid" Bouncer

The old system (called ICN-ETM) worked like a rigid grid of security cameras. It looked at small, fixed squares of the detector.

• The Flaw: If two particles landed right next to each other, the old system couldn't tell them apart. It would see them as one big blob.
• The Limitation: It was like trying to sort a pile of mixed Lego bricks by only looking at them in 3x3 inch boxes. If two bricks touched, the system got confused. It also couldn't handle the "thunderstorm" of background noise very well, often getting overwhelmed and missing interesting events.
• The Constraint: It had to make a decision in microseconds. If it took too long, the data would be lost forever.

2. The Solution: The "Social Network" Bouncer

The new system (GNN-ETM) treats the detector not as a grid, but as a social network.

• The Analogy: Imagine every tiny sensor in the detector is a person at a party.
  • Old Way: You only look at people standing in specific squares.
  • New Way: You look at who is talking to whom. If a group of sensors (people) are all "talking" (detecting energy) and they are close to each other, the system realizes, "Ah, this is one conversation (one particle)." If two groups are talking but are far apart, it knows they are two different conversations.
• The Magic: Because it understands the relationships between the sensors, it can separate two particles that are very close together (like two people whispering next to each other) much better than the old grid system.

3. The Challenge: The "Instant" Brain

Neural networks (AI) are usually heavy, slow, and require massive servers. But a particle collider needs a decision in 3.168 microseconds (that's 0.000003 seconds).

• The Hardware: They couldn't use a normal computer. They had to build this AI directly onto a FPGA (a reprogrammable chip). Think of this as carving a custom, ultra-fast brain out of silicon that fits inside a shoebox.
• The Compression: To make the AI fast enough, they had to "shrink" it. They reduced the precision of the math (like using a ruler with fewer markings) and cut out unnecessary connections, similar to pruning a tree so it grows faster but still keeps its shape.

4. The Results: A Smarter Bouncer

When they tested this new system against the old one using both simulations and real data from the collider:

• Seeing the Unseeable: It could separate two particles that were very close together 20% better than the old system. This is like being able to hear two people whispering in a crowd when the old system could only hear one voice.
• Better Positioning: It could pinpoint where a particle hit with much higher accuracy (up to 18% better in the center of the detector).
• Filtering Noise: It has a "lie detector" built-in. It can tell the difference between a real particle from a collision and a random spark from background noise. It can reject 70% of the noise while keeping 97.5% of the real signals.
• Speed: It runs at the same speed as the old system, keeping up with the 8 million events per second the collider produces.

Why This Matters

This is a historic first. It is the first time a Graph Neural Network has been successfully run in real-time inside a particle physics experiment's trigger system.

The Big Picture:
Think of the old system as a stiff robot that follows a checklist. The new system is a smart detective that looks at the whole picture, understands relationships, and makes a judgment call instantly. This allows scientists to catch rare, subtle events (like potential new particles) that were previously hidden in the noise, potentially leading to new discoveries about the universe.

In short: They taught a super-fast computer chip to "think" like a human detective, allowing it to spot the needle in the haystack while the haystack is on fire.

Technical Summary

1. Problem Statement

The Belle II experiment at the SuperKEKB collider faces increasing challenges due to higher instantaneous luminosity, which leads to a significant rise in beam-induced background. The existing Level-1 (L1) trigger system for the Electromagnetic Calorimeter (ECL) relies on a fixed-logic algorithm (ICN-ETM) with several critical limitations:

• Rigid Clustering: It uses a static $3\times3$ window logic that cannot resolve overlapping clusters (e.g., two close-by photons from boosted neutral pions) or clusters spanning detector region boundaries (barrel vs. endcaps).
• Duplicate Hits: The logic often generates duplicate cluster candidates, wasting resources and distorting cluster counting.
• Poor Resolution: Position resolution for high-energy clusters is limited because the cluster position is assigned to the center of the highest-energy trigger cell (TC), rather than a weighted average.
• Scalability: The system is limited to processing a maximum of six clusters per event due to FPGA resource constraints.
• Latency Constraints: The system must operate with a hard latency constraint of $\approx 5 \, \mu\text{s}$ and a throughput of 8 MHz.

The goal was to develop a more flexible, accurate, and background-resistant clustering algorithm that could run in real-time on FPGA hardware within these strict constraints.

2. Methodology

The authors developed GNN-ETM, a real-time Graph Neural Network (GNN) based trigger module. The methodology involves three main pillars: algorithm design, model compression, and hardware implementation.

A. Algorithm Design (CaloClusterNet)

• Graph Representation: Calorimeter Trigger Cells (TCs) are treated as graph nodes. Edges are dynamically constructed based on learned spatial relations rather than fixed geometry.
• Architecture: The model uses GravNet layers (a type of dynamic GNN) to perform message passing. It consists of two GravNet blocks.
• Object Condensation: Instead of predicting a fixed number of clusters, the network uses an Object Condensation loss. It predicts a "condensation point" (a latent space coordinate) and a $\beta$ value for each node. Nodes with high $\beta$ values attract nearby nodes, effectively clustering them.
• Outputs: For each identified cluster, the network predicts:
  • Energy scale factor.
  • 3D Position ($x, y, z$).
  • A signal classifier score ($p_{\text{signal}}$) to distinguish physics signals from beam background.
• Post-Processing: A "Condensation Point Selection" algorithm selects isolated candidates based on $\beta$ thresholds and latent space distance to finalize the cluster list.

B. Model Compression for FPGA

To fit the model onto an AMD Ultrascale XCVU190 FPGA:

• Quantization: Mixed-precision quantization-aware training (QKeras) was used. Weights and activations were quantized to fixed-point formats (e.g., Q3.5, Q4.10) to minimize resource usage.
• Pruning: Low-magnitude pruning (40% rate) was applied to reduce multiplication operations.
• Activation Approximation: The sigmoid activation function was replaced with a linear approximation to reduce logic complexity.
• Input Handling: Inputs are limited to 32 TCs per event (zero-padded if fewer, truncated if more), covering >99.99% of events even under high background.

C. Hardware Implementation

• Platform: Implemented on the Universal Trigger Board 4 (UT4) using Chisel for hardware generation and Vitis HLS for synthesis.
• Architecture: A pipelined dataflow architecture with three stages:
  1. Preprocessing: Address generation, stream compaction (reducing 576 TCs to 32), and feature calibration.
  2. GNN Accelerator: Custom Processing Elements (PEs) for GravNetConv (graph building, message passing) and Condensation Point Selection.
  3. Postprocessing: Merging data streams and encoding cluster information.
• Integration: The system interfaces with the Belle II trigger chain via the Belle2Link subsystem, operating synchronously with the existing 8 MHz clock.

3. Key Contributions

• First Real-Time GNN in a Collider Trigger: This is the first deployment of a GNN-based reconstruction system within the real-time L1 trigger path of a collider experiment.
• Dynamic Clustering: Successfully implemented dynamic graph construction and object condensation on FPGA, overcoming the limitations of static window-based algorithms.
• Signal Classifier: Introduced a native background rejection mechanism (signal classifier) within the trigger logic, allowing for flexible rate control without hard energy cuts.
• End-to-End Validation: Provided a comprehensive validation framework comparing QKeras simulations, C-level HLS simulations, and cycle-accurate RTL simulations against hardware data (Cosmic rays and collision data).

4. Results

The system was evaluated using simulated data and real collision data (Run A, Dec 2024).

• Latency & Throughput:
  • Throughput: Sustains the required 8 MHz trigger rate.
  • Latency: End-to-end latency is 3.168 $\mu$s. While this exceeds the strict 5 $\mu$s limit for the final trigger decision (currently it runs in parallel), it demonstrates feasibility. Future optimizations (higher frequency, reduced layers) aim to meet the strict deadline.
• Clustering Performance:
  • Efficiency: Matches the baseline ICN-ETM efficiency for isolated clusters.
  • Overlapping Clusters: For non-isolated photons (overlapping clusters), GNN-ETM improves cluster finding efficiency by up to 20% compared to ICN-ETM.
  • Position Resolution: Improves position resolution by up to 18% in the central barrel region for high-energy clusters due to the ability to use spatial correlations across multiple TCs.
  • Purity: Increases cluster purity by up to 20% at low energies for isolated clusters.
• Background Rejection:
  • The signal classifier achieves a 97.5% signal retention rate while rejecting up to 72% of background clusters in the barrel region (for specific energy ranges).
  • This leads to a 20% reduction in the L1 trigger rate for background-dominated events compared to the baseline.
• Resolution:
  • Energy resolution is comparable to the baseline.
  • Angular resolution ($\theta$ and $\phi$) is significantly smoother and more precise than the "spiky" resolution of the baseline (which is limited by TC binning).

5. Significance

This work represents a paradigm shift in high-energy physics trigger systems. It proves that complex, dynamic machine learning models (specifically GNNs) can be deployed on FPGAs with deterministic latency and high throughput, challenging the dominance of fixed-logic algorithms.

• Physics Impact: The improved ability to resolve overlapping photons and reject background directly enhances the sensitivity of Belle II to rare decays and dark sector searches (e.g., dark photons, axion-like particles) which often manifest as low-multiplicity, low-energy, or overlapping signatures.
• Technological Precedent: It sets a precedent for future experiments (like the HL-LHC upgrades) where data rates will be even higher, and advanced ML inference will be required at the trigger level to manage data volumes effectively.
• Hardware-ML Synergy: The paper provides a blueprint for the co-design of ML algorithms and FPGA architectures, addressing challenges like quantization, pruning, and dynamic graph construction in real-time environments.