Hit-Level GNN Filtering

• The paper presents a hit-level GNN filtering approach that transforms detector hits into graph representations, achieving 83% background rejection and 95% signal efficiency in real-time settings.
• Methodologies leverage FPGA-optimized message passing with quantized features and tiered thresholding to process high-background collider data with low latency.
• Node-wise adaptations, including a Mixture-of-Experts gating mechanism, customize spectral filters to local graph structures, further enhancing performance.

Hit-level GNN-based filtering refers to the application of Graph Neural Network (GNN) models to classify or suppress detector hits at the raw data level, typically in high-background environments such as collider central drift chambers. The approach transforms collections of sense-wire signals into graphs, leverages both spatial and temporal relationships among hits, and uses learned message-passing architectures to discriminate between true signal and background noise. Recent work has emphasized the deployment of these algorithms as real-time, low-latency solutions, including hardware acceleration on FPGAs, to meet the stringent demands of modern particle physics experiments.

1. Core Methodology of Hit-Level GNN Filtering

The essence of hit-level GNN filtering lies in converting raw detector output—hits on sense wires—into a graph representation $G = (V, E)$ where each node represents a hit and edges encode local physical connectivity or kinematic compatibility. Node and edge features typically include geometric coordinates (e.g., $(x_i, y_i)$ or $(r, \phi)$), charge (ADC), timing (TDC), and local differences such as $\Delta r$, $\Delta\phi$, and $\Delta\mathrm{TDC}$.

The GNN architecture performs $T$ rounds of message passing, with each round involving:

• Edge Update:

$$e_{ij}^{(t)} = \sigma(\mathrm{MLP}_e([h_i^{(t-1)} \| h_j^{(t-1)} \| e_{ij}^{(t-1)}]))$$

or, in hardware-constrained variants,

$e_{ij}' = \sigma_1(W_1[h_i, h_j, e_{ij}] + b_1)$

• Node Aggregation:

$m_j = \bigoplus_{i \in \mathcal{N}(j)} e_{ij}'$

with $\bigoplus$ a hardware-friendly aggregate (typically max, to avoid bit-width growth).

• Node Update:

$h_j' = \sigma_2(W_2 [h_j, m_j] + b_2)$

Following message-passing, either edge or node scores are produced for downstream classification. In node-wise filtering, a final MLP converts $h_j'$ into a scalar $s_j$ indicating the likelihood that node $j$ represents signal.

2. Domain Applications: Belle II and STCF Drift Chambers

Belle II Level-1 Trigger

To handle extreme backgrounds at the Belle II experiment, an Interaction-Network-style GNN was quantized and compressed for FPGA operation (Heine et al., 6 Nov 2025). The model uses:

• Nodes: $x_i = [x_i, y_i, \mathrm{ADC}_i]^T$ (positions quantized, $\mathrm{ADC}$ in 4 bits)
• Edges: $$e_{ij} = [\Delta r_{ij}, \Delta\phi_{ij}, \Delta\mathrm{TDC}_{ij}]^T$$ (all features quantized to 4 bits)
• Static graph generation enforces only physically plausible connections ($\Delta\ell$ and $\Delta w$ constraints)
• Only two rounds of message passing were retained to minimize latency.

STCF Drift Chamber

For the STCF facility, the Graph Neural Filter (GNF Algorithm) treats each hit as a graph node with $(r, \phi)$, ADC, TDC features, and builds the hit graph using adjacency and angular cuts (Jia et al., 12 Jul 2025). Eight rounds of message passing are performed with MLP-based edge scoring and a tiered, layer-aware thresholding scheme (see Section 4). Hits connected by kept edges form the high-purity set for subsequent tracking, with noise rejection and signal retention measured independently.

3. Hardware Acceleration and FPGA Optimizations

Real-time filtering at high rates necessitates accelerator-friendly GNN designs. The Belle II implementation demonstrates a complete pipeline on an AMD Ultrascale XCVU190, with the architecture parallelized across 20 $\phi$-sectors:

Metric	Value (per sector, XCVU190)	Notes
Sustained clock rate	$31.804$ MHz	Matches CDC data rate
Pipeline latency (4 logic stages)	$632.4$ ns	4 stages × $163.8$ ns each
LUT utilization	$35.65\%$	Sufficient margin for multi-sector scaling
Flip-Flop utilization	$29.75\%$
DSP (Mult. units) usage	$0$	Integer-only arithmetic; all multipliers avoided
Signal hit efficiency	$95\%$ (quantized)	$87\%$ background rejection (floating point), $83\%$ (4-bit)

Compression is achieved by halving hidden dimensions, pruning ($50\%$ weight sparsity), quantization-aware training (4 bits for input/weights/activations, 16 bits for bias, 8 bits for output), and activation simplification (sigmoid replaced by linear thresholding).

4. Filtering Strategies and Training Approaches

Static Graph Wiring and Sector Splitting

Efficient graph construction exploits detector geometry and expected track patterns, limiting $\mathcal{N}(i)$ to kinematically plausible neighboring hits based on layer and wire adjacency ($\Delta \ell$, $\Delta w$ rules). This curtails graph size and accelerates both software and hardware dataflow.

Tiered Thresholding

In STCF-style hit filtering, naively binarizing GNN outputs can degrade performance in certain layer regimes. Instead, a tiered threshold is adopted:

• Boundary layers: no filtering
• Innermost superlayers: $t_\text{low}=0.10$
• Other layers: $t_\text{high}=0.50$

Hits not attached by any retained edge are classified as background. This layer-aware approach balances background suppression with signal efficiency across varying detector regions.

Loss and Regularization

Training proceeds on MC datasets, using standard binary cross-entropy for edge or node classification. Strong class imbalance is addressed by loss weighting and architectural features (such as residual connections and the tiered thresholding scheme). No dropout was required in GNF thanks to robust thresholding and loss design (Jia et al., 12 Jul 2025).

5. Node-Wise Filtering: Mixture of Experts and Local Adaptation

While most hit-level applications rely on uniform GNN architectures, recent developments in node-wise (hit-wise) filtering suggest further improvements by adapting the spectral filter at each node. The Node-MoE approach formalizes this via a Mixture-of-Experts:

• Each node computes a context vector $z_i$ measuring local homophily/heterophily.
• A gating network uses $z_i$ to assign soft weights $\alpha_{i,e}$ among $m$ experts, each a GNN with a distinct spectral filter.
• Node representation is fused as $h_i^\text{MoE} = \sum_e \alpha_{i,e} h_i^{(e)}$.
• Theoretical analysis (under a mixed contextual SBM) demonstrates that such node-wise filtering removes the fundamental "single-filter" tradeoff, enabling near-optimal performance in graphs with mixed local structure (Han et al., 5 Jun 2024).

Empirical findings: On real and simulated benchmarks, Node-MoE achieves both statistical and practical superiority over all prior single-filter or global-filter GNNs, with best-in-class accuracy gains across both homophilic and heterophilic settings.

6. Performance, Impact, and Scalability

Hit-level GNN-based filtering enables significant gains in beam background suppression while simultaneously reducing downstream fake track rates without loss of signal efficiency:

• Belle II prototype on real data: $83\%$ background rejection and $95\%$ signal efficiency at $632.4$ ns latency, per sector (Heine et al., 6 Nov 2025).
• STCF GNF Algorithm: $86.8\%$ noise rejection and $98.2\%$ signal selection, reducing fake-track rates by $80-88\%$ with no degradation in low-$p_T$ sensitivity (Jia et al., 12 Jul 2025).

Full-detector operation is achieved by sector-wise parallel GNN engine instantiation, exploiting remaining FPGA resources for scalability. Architectural choices (reuse factor, pipeline depth) enable absorption of increasing detector occupancy, with migration paths to later-generation FPGAs for even higher throughput.

A plausible implication is that node-wise adaptive GNN filtering (Node-MoE and successors) has potential to further improve hit-level suppression in environments with mixed background patterns, though direct deployment in high-throughput hardware and for streaming detector readouts is an open direction.

7. Connections to Broader GNN Filtering Research

Hit-level GNN-based filtering sits at the intersection of high-energy detector data processing and recent advances in spectral GNNs. Core ideas such as adaptive local filtering, message passing with quantized weights, and mixture-of-experts gating for non-uniform graph structure are broadly applicable. The field is evolving towards models that:

• Optimize for real-time inference under hardware and throughput constraints
• Exploit local adaptation to inhomogeneous environments
• Incorporate domain-specific knowledge in static graph construction and sectorization

The principle that node-wise filtering offers theoretical and empirical advantages over any single global filtering strategy holds for general graphs, not just collider detectors (Han et al., 5 Jun 2024). As detector rates and occupancy increase, and as heterogeneity of noise patterns becomes more pronounced, these advanced GNN filtering approaches are likely to play a decisive role in next-generation trigger and data-reduction pipelines.