FM4NPP: A Scaling Foundation Model for Nuclear and Particle Physics

## Abstract

Abstract Large language models have revolutionized artificial intelligence by enabling large, generalizable models trained through self-supervision. This paradigm has inspired the development of scientific foundation models (FMs). However, applying this capability to experimental particle physics is challenging due to the sparse, spatially distributed nature of detector data, which differs dramatically from natural language. This work addresses if an FM for particle physics can scale and generalize across diverse tasks. We introduce a new dataset with more than 11 million particle collision events and a suite of downstream tasks and labeled data for evaluation. We propose a novel self-supervised training method for detector data and demonstrate its neural scalability with models that feature up to 188 million parameters. With frozen weights and task-specific adapters, this FM consistently outperforms baseline models across all downstream tasks. The performance also exhibits robust data-efficient adaptation. Further analysis reveals that the representations extracted by the FM are task-agnostic but can be specialized via a single linear mapping for different downstream tasks.

## Introduction

The emergence of large-scale language and vision models (Wang et al. [2023](https://arxiv.org/html/2508.14087v1#biba.bib49)) has marked a paradigm shift from specialized neural architectures, tailored to individual tasks, toward universal, scalable, and multitasking models. These large models, containing billions of parameters and trained through self-supervised learning on massive unlabeled datasets, can be efficiently adapted to diverse downstream tasks, ranging from language translation and code generation to general reasoning. Recognizing their transformative potential, the scientific community has termed these scalable, general-purpose models as foundation models (FMs) (Bommasani et al. [2021](https://arxiv.org/html/2508.14087v1#biba.bib7)). Among their underpinning features, FMs can leverage self-supervised learning on extensive unlabeled datasets, allowing them to develop generalized representations adaptable to various downstream tasks with minimal additional labeled training. However, scientific data often fundamentally differ from natural language or visual data. Hence, the design and implementation of FMs for scientific fields still faces challenges (Li et al. [2024](https://arxiv.org/html/2508.14087v1#biba.bib28); Pyzer-Knapp et al. [2025b](https://arxiv.org/html/2508.14087v1#biba.bib38)).

This work investigates developing FMs tailored for experimental nuclear and particle physics (NPP), emphasizing data from the Relativistic Heavy Ion Collider (RHIC) and the sPHENIX detector (Brookhaven National Laboratory [2025](https://arxiv.org/html/2508.14087v1#biba.bib8)). NPP research uses particle colliders, such as RHIC or the Large Hadron Collider (LHC), to explore subatomic phenomena.
Discovery of the Higgs boson exemplified the transformative significance of collider-based NPP (Collaboration, Aad et al. [2012](https://arxiv.org/html/2508.14087v1#biba.bib14)).
In particular, RHIC collides heavy ions and polarized protons, enabling essential studies of quark-gluon plasma and the structure of protons and nuclei (Belmont et al. [2024](https://arxiv.org/html/2508.14087v1#biba.bib5)). Commissioned in 2023 (Moskowitz [2023](https://arxiv.org/html/2508.14087v1#biba.bib32)), the sPHENIX detector features advanced tracking and calorimetry and generates extensive and complex data. The complexity of collider data and the breakthrough science it enables has motivated exploration of new data processing tools like FMs that employ self-supervised learning.

Figure: Figure 1: Overview of a scaling pretrained foundation model that can be adapted to various downstream tasks.
Refer to caption: intro_fig_white.png

However, developing an FM for NPP poses several challenges. The sparse, three-dimensional (3D)-spacepoint nature of collider data lacks an established framework for formulating self-supervised tasks.
Additionally, optimal neural architectures and the scaling behavior of pre-training losses with respect to model and data size remain unknown. Crucially, it is uncertain if neural representations from a frozen, pre-trained FM can generalize effectively to various downstream tasks, thereby outperforming existing traditional solutions and specialized AI models.

Here, we take a first step toward enabling the use of FMs for NPP by adopting a cost-effective two-stage paradigm: (1) pretrain a large FM using a self-supervised objective and (2) pair the frozen FM with lightweight, task-specific adapters (Figure [1](https://arxiv.org/html/2508.14087v1#Sx1.F1)). The core hypothesis is that a sufficiently trained FM encodes rich, task-agnostic representations that can be efficiently adapted to diverse downstream tasks with minimal additional training.

To this end, we construct a large-scale dataset, exceeding 11 million simulated collision events and characterized by sparse, high-dimensional detector data. We also define three downstream tasks with corresponding labeled datasets to evaluate FM adaptability. We introduce a self-supervised pre-training strategy tailored to the sparsity and structure of detector data and demonstrate strong neural scaling behavior with models up to 188 million parameters. With frozen FMs and simple adapters, we achieve state-of-the-art performance across all downstream tasks. This analysis further reveals that FM representations are broadly task-agnostic and can be specialized using a single linear transformation. In summary, our contributions are:

- •
A large-scale, open benchmark dataset for FM training and evaluation in particle physics.
- •
A self-supervised pre-training method designed for sparse detector data.
- •
Empirical evidence of scaling behavior and data-efficient adaptation with frozen FMs.
- •
Insight into the structure and adaptability of FM representations across diverse tasks.

## Related Work

Figure: Figure 2: TPC data (spacepoints) and downstream tasks.
Refer to caption: x1.png

##### Scientific Foundation Models.

Developing FMs for scientific domains is a promising yet formidable endeavor. Progress has been most evident in domains where data exhibit modality structures similar to language or vision. For instance, Aurora (Bodnar et al. [2025](https://arxiv.org/html/2508.14087v1#biba.bib6)) is an atmospheric FM trained on continuous spatiotemporal climate data, and recent work has demonstrated FM-based disease detection from retinal images (Zhou et al. [2023](https://arxiv.org/html/2508.14087v1#biba.bib51)). However, many scientific disciplines, including particle physics, materials science, and single-cell omics, present unique challenges like irregularly structured and sparse data. Traditional approaches, such as graph neural networks (GNNs), are well-suited for sparse data, but they face scalability issues due to phenomena, e.g., oversmoothing (Rusch, Bronstein, and Mishra [2023](https://arxiv.org/html/2508.14087v1#biba.bib40)). Surveys in materials science (Pyzer-Knapp et al. [2025a](https://arxiv.org/html/2508.14087v1#biba.bib37)) and single-cell omics (Ma et al. [2024](https://arxiv.org/html/2508.14087v1#biba.bib30)) emphasize additional bottlenecks, including limited data availability and high computational costs. These challenges also apply to NPP, where it remains unclear how best to model extremely sparse data, how much data are needed, and whether pretraining benefits can effectively transfer to downstream tasks. This work takes a first step toward addressing these questions by developing a scalable FM for NPP data, focused on efficient pretraining, architectural scalability, and downstream generalization.

##### Scalable Neural Architectures.

Three neural network architectures are prominent for their scalability: Transformers, Mixture-of-Experts (MoE), and State Space Models (SSMs). The Transformer architecture (Vaswani et al. [2017](https://arxiv.org/html/2508.14087v1#biba.bib48)) has revolutionized deep learning via self-attention, enabling effective modeling of long-range dependencies. This has led to widespread adoption in both natural language processing (NLP) and computer vision (Dosovitskiy et al. [2021](https://arxiv.org/html/2508.14087v1#biba.bib16)). However, the quadratic time and space complexity of self-attention limits scalability on long sequences – a critical bottleneck for scientific data. MoE architectures (Fedus, Zoph, and Shazeer [2022](https://arxiv.org/html/2508.14087v1#biba.bib17)) improve inference efficiency by activating only a subset of the model per input, although they face challenges, such as training instability and expert imbalance.
The Mamba architecture (Gu and Dao [2024](https://arxiv.org/html/2508.14087v1#biba.bib19)), an SSM variant, achieves linear time complexity and shows competitive or superior performance to Transformers. Given the relatively large number of spacepoints per collision event, which can result in especially long sequences, we explore SSMs as a backbone due to their favorable training efficiency and memory usage.

##### AI Models in NPP.

In collider physics, high-energy particles collide to produce new particles, whose trajectories—called tracks—are reconstructed from discrete spacepoints recorded by layered detector components. Track finding, or assigning spacepoints to different tracks, is one of the most important tasks. Traditional algorithms rely on combinatorial seeding followed by Kalman-filter-based refinement (Kalman [1960](https://arxiv.org/html/2508.14087v1#biba.bib24)). These classical methods are computationally expensive and difficult to parallelize on modern accelerators.
GNN‑based approaches have become popular in track finding. Exa.TrkX (Ju et al. [2021](https://arxiv.org/html/2508.14087v1#biba.bib23)) formulates the task as edge classification, whereas EggNet (Calafiura et al. [2024](https://arxiv.org/html/2508.14087v1#biba.bib10)) employs contrastive learning followed by clustering. Each predicted track then corresponds to a connected subgraph of spacepoints.
Other recent work has introduced Transformer- (Stroud et al. [2024](https://arxiv.org/html/2508.14087v1#biba.bib46)) and SSM-based (Jiang and Qian [2025](https://arxiv.org/html/2508.14087v1#biba.bib22)) tracking models.

While these models are promising – with some achieving strong results using fewer than one million parameters – there is no systematic study of scaling behavior. Moreover, open datasets designed for scaling and evaluating FMs are limited.
In this work, more than 11 million simulated collision events are generated, affording comprehensive scaling studies.
We also develop an FM with 188 million parameters, two orders of magnitude larger than prior models, and evaluate its performance in tracking and broader NPP tasks.

## Particle Detector Dataset

Figure: Figure 3: (a) Hierarchical Raster Scan strategy to serialize the unordered spacepoints into a 1D sequence. (b) A Mamba FM backbone for k-Next-Nearest-Neighbor prediction.
Refer to caption: x2.png

##### Dataset.

As part of the sPHENIX detector’s central tracking system, the high‑granularity Time Projection Chamber (TPC) (Klest [2020](https://arxiv.org/html/2508.14087v1#biba.bib26)) records more than $85\%$ of the total data volume.
The TPC consists of 48 concentric cylindrical readout layers, encompassing approximately 160,000 channels that each record 260 of time samples, totaling 41.6 million voxels.
Functioning as a three-dimensional camera, the TPC records the paths of particles emerging from collision events, delivering continuous 3D spacepoint information.

We use a realistic simulation pipeline in production to generate more than 11 million proton-proton (p+p) collisions at a center-of-mass energy of $\sqrt{s}=200\,$GeV.
The natural sparsity of events in p+p collisions makes them an ideal testing ground for developing an FM for NPP applications.
The simulation pipeline includes real detector geometry, electromagnetic fields, hadronic interactions, continuous energy loss, multiple scattering, decay processes, secondary particle production, and precise energy deposition.
The raw detector hits subsequently are reconstructed to spacepoints and used as inputs in this work.
More concretely, a collision event $E$ is represented as a set of spacepoints $\{s_{i}\}$, where each spacepoint is expressed by its deposit energy and location $(\mathcal{E},x,y,z)$. The number of spacepoints per event can vary from hundreds to thousands.

##### Downstream Tasks.

We select three complementary downstream tasks to evaluate the generalizability of an FM: Track Finding, Particle Identification (PID), and Noise Tagging. Track Finding assigns each spacepoint to its corresponding predicted track as shown in Figure [2](https://arxiv.org/html/2508.14087v1#Sx2.F2)(a).
Assume there are $m$ tracks $\{T_{j}\}_{j=1}^{m}$, where each track $T_{j}$ consists of its associated spacepoints $\{s_{i}\in T_{j}\}$. The goal of track finding is to predict a partition $P$ over the set of spacepoints, where $P_{i}^{j}=1$ if spacepoint $s_{i}$ is assigned to track $T_{j}$. The number of tracks can vary from event to event. This task is analogous to instance segmentation in computer vision.

To evaluate performance, we employ both conventional physics-motivated metrics, tracking efficiency and purity (Calafiura et al. [2018](https://arxiv.org/html/2508.14087v1#biba.bib11)), as well as the statistical metric Adjusted Rand Index (ARI) (Hubert and Arabie [1985](https://arxiv.org/html/2508.14087v1#biba.bib21)). As the exact definition of whether or not a predicted track matching a true track can differ among physics experiments, we adopt the “double-majority rule” from the TrackML challenge (Amrouche et al. [2020](https://arxiv.org/html/2508.14087v1#biba.bib3)).
The rule enforces that a predicted track is successfully matched to a true track only when greater than 50% of the predicted track’s spacepoints belong to that track and more than 50% of the true track’s spacepoints are present in the predicted track.
This stringent rule guarantees neither predicted tracks nor true tracks are matched at least once.
Then, tracking efficiency (recall) is defined as the ratio between the true positive and total number of truth tracks, while tracking purity (precision) is the ratio between the true positive and total number of predicted tracks.

PID aims to label each spacepoint to the particle species that produced it, i.e., pion, kaon, proton, electron, and others. This is comparable to a segmentation task in computer vision. Figure [2](https://arxiv.org/html/2508.14087v1#Sx2.F2)(b) depicts an example.
Noise Tagging, the third downstream task, seeks to identify spacepoints associated to low-momentum secondary particles, primarily delta electrons as they typically are not associated with physics observables of interest. This also can be considered a segmentation task.
For these two downstream tasks, we report overall accuracy, macro‐averaged precision and recall.
Additional information about the TPC detector, data generation pipeline, and statistical analysis are included in Appendix A.

## Methodology

This section introduces the scalable FM for NPP, including a novel serialization method for sparse spacepoints, adaptation to the Mamba architecture, and a self-supervised pretraining objective, and lightweight adapter models for downstream tasks. Additional information is included in Appendix B.

### Self-supervised Scaling Foundation Model

##### Serialization of Spacepoints.

A key challenge in applying sequence-based models like Mamba to particle detector data is in serializing the unordered set of 3D spacepoints ${s_{i}}$ from an event $E$ into a meaningful one-dimensional (1D) sequence.
The serialization strategy must balance two competing objectives: preserving the global structure of particle trajectories, which typically propagate outward from the collision point, and maintaining local continuity along individual tracks $T_{j}$ to retain fine-grained geometric information.
Naive serialization schemes struggle to achieve this balance. For example, space-filling curves (e.g., Hilbert or Z-order) prioritize spatial locality but often interleave points from different tracks, disrupting trajectory coherence.
Conversely, sorting points by their radial distance preserves the outward particle flow but scatters spacepoints from the same track across distant positions in the sequence, breaking local continuity. An effective serialization must navigate this trade-off, allowing the model to learn both global and local physics from a sequential input.

We propose a Hierarchical Raster Scan strategy to serialize the unordered spacepoints ${s_{i}}$ into a 1D sequence suitable for sequence models as shown in Figure [3](https://arxiv.org/html/2508.14087v1#Sx3.F3)(a).
First, all spacepoints are transformed from Cartesian $(x,y,z)$ to a cylindrical-polar system $(r,\phi,\eta)$ that better reflects the geometry and symmetries of collider experiments, where $r$ is radial distance, $\phi$ depicts the azimuthal angle, and $\eta$ represents the pseudorapidity (angle to the beam axis).
The raster scan method operates on two levels. The first is inter-box ordering, where spacepoints are initially partitioned into non-overlapping 3D spatial boxes. Then, these boxes are ordered based on the $(r,\phi,\eta)$ coordinates of their geometric centers, starting from the innermost region and progressing outward. This produces a global ordering over the spatial domain. The second is intra-box ordering, where, within each box, spacepoints are sorted by their radial coordinate $r$, which generally aligns with the direction of particle propagation.
By concatenating the intra-box sequences according to the inter-box order, we obtain a globally serialized sequence that preserves both local spatial continuity and global physical progression. This hierarchical structure captures important geometric and physical priors while producing a format compatible with sequence models.
Specifically, we partition the spatial domain into a $6\times 8\times 8$ grid along the $(r,\eta,\phi)$ axes, respectively. The $r$ bins are aligned with the physical boundaries of the TPC detector layers, while the $\eta$ and $\phi$ bins are determined using frequency-based binning to ensure balanced point distributions across the grid.

##### Mamba as a FM Model Backbone.

Mamba is a selective SSM that efficiently processes long sequences, achieving linear time complexity (Gu and Dao [2023](https://arxiv.org/html/2508.14087v1#biba.bib18)). It features a selection mechanism that makes its internal state matrices input-dependent, allowing the model to dynamically focus on relevant information and filter out noise – all while using a hardware-aware algorithm for fast computation. In this work, we employ Mamba2 (Dao and Gu [2024](https://arxiv.org/html/2508.14087v1#biba.bib15)), which further improves upon this foundation. Mamba2 introduces structured State Space Duality (SSD), a new theoretical framework that simplifies the architecture and enhances hardware utilization, leading to significant speedups in both training and inference.

We treat every spacepoint as an input “token” in a sequence.
To map an input tuple $(\mathcal{E},r,\phi,\eta)$ to the model width $d_{\text{model}}$, we employ a two-pathway process inspired by Neural Radiance Fields (Mildenhall et al. [2021](https://arxiv.org/html/2508.14087v1#biba.bib31)). First, the feature component $\mathcal{E}$ is projected into a feature embedding of dimension $d_{\text{model}}$. Concurrently, the spatial coordinates $(r,\phi,\eta)$ are transformed with a high-frequency positional encoding function, $\gamma(\cdot)$, which uses sine and cosine transformations. Then, this encoded position is also projected into a positional embedding of dimension $d_{\text{model}}$. The final representation is the element-wise sum of the feature and positional embeddings, yielding a single vector of size $d_{\text{model}}$ that holistically captures the event’s properties and location.

##### Self-supervised Pretraining Objectives.

To create a self-supervised pretraining task, the prediction objective must be decoupled from the sequence order as a naive “next-spacepoint prediction” would learn artifacts of the serialization itself. The target for any given spacepoint $s_{i}$, must be defined by its geometric relationship to other spacepoints in 3D, not its 1D sequence position. While predicting nearest neighbors is a natural geometric objective, a standard k-Nearest Neighbor task is unsuitable in an autoregressive framework due to information leakage from previously seen spacepoints. We partially address this by introducing k-Next-Nearest-Neighbor prediction (Figure [3](https://arxiv.org/html/2508.14087v1#Sx3.F3)(b)), which aligns the objective with particle propagation. For any query spacepoint $s_{i}$, the model’s task is to predict its $k$ spatially nearest spacepoints that reside only within its next neighborhood set $\mathcal{N}_{c}(s_{i})=\{s_{j}\in E\mid r_{j}>r_{i}\}$, which consists of spacepoints with a larger radius than $r_{i}$. The loss for $s_{i}$ is the squared Euclidean distance between the predicted coordinates of these $k$ neighbors ($\mathbf{s}_{i}$) and the truth coordinates ($\mathbf{y}_{i}$), given by $\mathcal{L}_{i}=||\mathbf{s}_{i}-\mathbf{y}_{i}||_{2}^{2}$. Note that a larger $k$ means the task involves predicting more distanced spacepoints. Hence, it is inherently more difficult.

Another obstacle in training with particle detector data is the variance in their sparsity. Rare but dense events tend to be easier to predict as points are closer to each other. This can lead to training instability. To mitigate this, we introduce an event-difficulty rescaling strategy. Events are binned by their average k-neighborhood distance (a proxy for difficulty), and the loss for each event is re-weighted by a factor corresponding to its bin. The final batch loss is the average of these re-weighted event losses, ensuring the training process is not biased by easier events.

Figure: Figure 4: The pretrained FM is kept frozen during training of the adapter models for downstream tasks. The adapter models for particle identification and noise tagging share the same architecture but are trained independently.
Refer to caption: x3.png

### Adaptive Models for Downstream Tasks

#### Track Finding.

Figure [4](https://arxiv.org/html/2508.14087v1#Sx4.F4) depicts how our downstream adapter model for track finding, formulated as an instance segmentation task, is inspired by image panoptic segmentation models (Cheng, Schwing, and Kirillov [2021](https://arxiv.org/html/2508.14087v1#biba.bib13); Cheng et al. [2022](https://arxiv.org/html/2508.14087v1#biba.bib12)) and adapted to sparse spacepoints data.

Point‑level features from a FM are first projected to spacepoint embeddings via a single linear layer, providing a probing point for the effect of the pretrained representation. We initialize $N$ learnable queries (track queries) $\mathbf{Q}=\{\mathbf{q}_{k}\}_{n=1}^{N}$ and refine them over $L$ transformer decoder layers. In each layer, cross‑attention aggregates information from spacepoint embeddings, modulated by an additive attention mask computed from intermediate assignment logits, followed by self‑attention among the queries.
The resulting refined track queries are passed through two separate multilayer perceptron (MLP) heads to produce a mask embedding track embedding and a classification score $\hat{y}_{n}$ . Point‑to‑query assignment probability $\hat{p}_{in}$ is computed as the sigmoid of the dot product between spacepoint embeddings and each track embedding.

Let $E=\{T_{j}\}_{j=1}^{M}$ be the set of true tracks of an event $E$. We match the refined track queries to $E$ via the Hungarian algorithm, minimizing the combined cost of Dice loss $\mathcal{L}_{\text{dice}}$, Focal loss $\mathcal{L}_{\text{focal}}$ on the per‐point assignments, and classification loss $\mathcal{L}_{\text{cls}}$ for track versus no‐object.
For each matched pair $(T_{j},\mathbf{q}_{n})$, the loss is

$$ $\mathcal{L}_{\text{match}}^{(j,n)}=\lambda_{\text{dice}}\,\mathcal{L}_{\text{dice}}^{(j,n)}+\lambda_{\text{focal}}\,\mathcal{L}_{\text{focal}}^{(j,n)}+\lambda_{\text{cls}}\,\mathcal{L}_{\text{cls}}^{(n)}.$ $$

Unmatched track queries incur only $\mathcal{L}_{\text{cls}}^{(n)}$. We also apply auxiliary losses at each decoder layer.
At inference time, each spacepoint $i$ is assigned to the track
$n_{i}^{*}=\arg\max_{n}\bigl{(}\hat{p}_{in}\cdot\hat{y}_{n}\bigr{)}$
and labeled accordingly.

#### Particle Identification and Noise Tagging.

For both PID and noise tagging tasks, illustrated in Figure [4](https://arxiv.org/html/2508.14087v1#Sx4.F4), our lightweight adapter first projects each $d$‑dimensional point feature into a $d_{p}$‑dimensional embedding via a linear layer then aggregates global context with a single self-attention layer. Finally, it feeds the result through an MLP classifier.

## Experiments and Results

Here, we begin by examining the scaling behavior of our FM with respect to model size, dataset size, and computational cost. We then benchmark the FM paired with lightweight adapters against strong baselines across three downstream tasks. Finally, we present additional analyses to better understand the adaptation behavior of the FM.

### Neural Scaling Behaviors of FM4NPP

**Table 1: Model Sizes and Compute Resources**
|  | Model Sizes |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- |
|  | m1 | m2 | m3 | m4 | m5 | m6 |
| Model Width | 64 | 128 | 256 | 512 | 1024 | 1536 |
| Model Params | 0.34M | 1.3M | 5.3M | 21M | 84M | 188M |
|  | Compute Resources |  |  |  |  |  |
| NVIDIA GPU | H100 80GB | A100 80GB |  |  |  |  |
| Num GPUs | 1 | 1 | 4 | 8 | 24 | 64 |
| Train Hrs | 10 | 12 | 20 | 32 | 50 | 72 |

Figure: Figure 5: Neural Scaling Behaviors of FM4NPP. We evaluate neural scaling trends on increasing (a) model parameter size $M$, (b) training spacepoint count $D$, and (c) compute in FLOPs. $C_{\text{min}}$ denotes the minimum $L$ for each compute.
Refer to caption: x4.png

**Table 2: Performance on Track Finding, Particle Identification, and Noise Tagging**
|  |  | Track Finding |  |  | Particle Identification | Noise Tagging |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| model | #trnbl para. | ARI$\uparrow$ | efficiency$\uparrow$ | purity$\uparrow$ | model | #trnbl para. | acc.$\uparrow$ | recall$\uparrow$ | pre.$\uparrow$ | acc.$\uparrow$ | recall$\uparrow$ | pre.$\uparrow$ |
| EggNet | $0.16$M | $0.7256$ | $74.19\%$ | $75.14\%$ | SAGEConv | $0.91$M | $0.7262$ | $0.4563$ | $0.6502$ | $0.9174$ | $0.7227$ | $0.8165$ |
| Exa.TrkX | $3.86$M | $0.8765$ | $91.79\%$ | $66.42\%$ | OneFormer3D | $44.95$M | $0.7701$ | $0.4897$ | $0.5767$ | $0.9646$ | $\mathbf{0.9404}$ | $0.8948$ |
| AdapterOnly | $2.39$M | $0.7243$ | $78.01\%$ | $64.54\%$ | AdapterOnly | $0.74$M | $0.6631$ | $0.3387$ | $0.6111$ | $0.9111$ | $0.6215$ | $0.8359$ |
| FM4NPP(m6) | $2.39$M | $\mathbf{0.9448}$ | $\mathbf{96.08\%}$ | $\mathbf{93.08\%}$ | FM4NPP(m6) | $0.74$M | $\mathbf{0.9039}$ | $\mathbf{0.7652}$ | $\mathbf{0.8782}$ | $\mathbf{0.9713}$ | $0.9367$ | $\mathbf{0.9190}$ |

We evaluate our FM’s scaling behavior across three axes: model size, dataset size, and compute budget. Results are summarized in Figures [5](https://arxiv.org/html/2508.14087v1#Sx5.F5)(a–c).

##### Model Scaling.

We construct a series of FMs with varying capacities, denoted m1 through m6 in Table [1](https://arxiv.org/html/2508.14087v1#Sx5.T1).
Figure [5](https://arxiv.org/html/2508.14087v1#Sx5.F5)(a) shows the validation mean squared error (MSE) plotted against model size on a log-log scale, revealing a clear power-law relationship.
As the number of parameters increases, validation loss consistently decreases, which aligns with neural scaling laws observed in language and other scientific domains (Kaplan et al. [2020](https://arxiv.org/html/2508.14087v1#biba.bib25); Hoffmann et al. [2022](https://arxiv.org/html/2508.14087v1#biba.bib20); Nguyen et al. [2023](https://arxiv.org/html/2508.14087v1#biba.bib33); Bodnar et al. [2025](https://arxiv.org/html/2508.14087v1#biba.bib6)). Notably, performance plateaus at m6, suggesting a possible saturation point, which we leave for future investigation.

#### Data Scaling.

To isolate the effect of training dataset size, we train the m3 model on varying subsets (1%, 2.4%, 11.6%, 20%, 47.6%, 100%) of the full dataset. Figure [5](https://arxiv.org/html/2508.14087v1#Sx5.F5)(b) shows how performance improves steadily with more data, again following a power-law trend. This suggests the FM can continue to benefit from the large-scale data routinely produced in collider experiments.

##### Compute Scaling.

Finally, we study the relationship between compute and model performance. Validation MSE is plotted against the total number of floating-point operations (FLOPs) used during training (Figure [5](https://arxiv.org/html/2508.14087v1#Sx5.F5)c). Models up to m3 are trained at 25%, 50%, and 100% of their total iteration budget, while larger models (m4-m6) are trained to full completion only. The results show that smaller models are initially more compute-efficient, but larger models outperform them when more resources are allocated. This highlights the importance of compute-optimal model scaling for deployment in high-throughput environments.
All experiments have been conducted using A100 and H100 GPUs with corresponding hardware costs summarized in Table [1](https://arxiv.org/html/2508.14087v1#Sx5.T1).

All models are trained with a batch size of 256. An optimal learning rate of $2\times 10^{-4}$ is selected through hyperparameter tuning on the m3 model and reused across all variants using the µ-parameterization principle (Vankadara et al. [2024](https://arxiv.org/html/2508.14087v1#biba.bib47)). This approach ensures consistent gradient flow across model sizes and enables zero-shot hyperparameter transfer (Yang et al. [2022](https://arxiv.org/html/2508.14087v1#biba.bib50)). Smaller models (m1, m2) are trained for 50,000 iterations, while larger models (m3–m6) are trained for 100,000 iterations. We apply cosine learning rate decay with 10,000-step linear warmup and use gradient clipping at a threshold of 0.1. All experiments employ the AdamW optimizer (Loshchilov and Hutter [2017](https://arxiv.org/html/2508.14087v1#biba.bib29)) with a weight decay of 0.01. Additional training details are provided in Appendix B.

### Performance on Downstream Tasks

##### Track Finding.

For baseline models used for track finding, we select Exa.TrkX (Ju et al. [2021](https://arxiv.org/html/2508.14087v1#biba.bib23)) and EggNet (Calafiura et al. [2024](https://arxiv.org/html/2508.14087v1#biba.bib10)). Both models are GNN-based and designed specifically for track finding. However, due to the difference in detector geometry, we must adapt these methods for our data (details are documented in Appendix C).
To verify embeddings extracted using the pretrained FM provide richer information, we also train the lightweight adapter model alone.

Table [5](https://arxiv.org/html/2508.14087v1#A3.T5) reports the track finding results of our FM with several baselines. All metrics are computed over the entire test set rather than averaged per event. For example, tracking efficiency is defined as the fraction of all true tracks in the dataset that are successfully matched.
Our model achieves higher performance on conventional clustering metrics such as ARI, and also outperforms other approaches in tracking efficiency (recall) and purity (precision).

We also compare this work against the official sPHENIX reconstruction pipeline, which employs a Cellular Automaton seeding followed by a Kalman filter (Osborn et al. [2021](https://arxiv.org/html/2508.14087v1#biba.bib35)). As that algorithm is optimized for high transverse momentum ($p_{\mathrm{T}}$), long tracks within the TPC acceptance, we restrict this comparison to tracks that leave at least 20 spacepoints in the TPC and satisfy $p_{\mathrm{T}}>$1\text{\,}\mathrm{GeV}$$ and $|\eta|<1.1$. Under these criteria, our model reaches a tracking efficiency of 99.6%, exceeding the sPHENIX pipeline’s 94.6%.

##### Particle Identification and Noise Tagging.

For the PID and noise tagging tasks, we experiment with four conventional GNN models and report on the best performing one, SAGEConv. The graph edge set is constructed by $k$-nearest neighbors with a distance cap. We also adapt and train a state-of-the-art segmentation model for 3D point cloud data named OneFormer3D (Kolodiazhnyi et al. [2024](https://arxiv.org/html/2508.14087v1#biba.bib27)).

Table [5](https://arxiv.org/html/2508.14087v1#A3.T5) reports the segmentation accuracy, as well as macro‐averaged recall and precision. For the PID task, our FM consistently outperforms all baselines, achieving the highest accuracy, recall, and precision. Meanwhile, for the noise tagging, the FM outperforms all GNN-based baselines with similar performance compared to OneFormer3D. It worth noting that OneFormer3D has about $45$ million trainable parameters, whereas our adapter head has $0.74$ million. More details about comparative model implementations and sample outputs are provided in Appendix C.

### Insights about FM Adaptation

We aim to further understand FM adaptation behaviors by answering the following research questions:

- •
Q1: Does increasing the size of the FM lead to improved performance on downstream tasks?
- •
Q2: Do larger FMs require fewer labeled examples to achieve comparable performance (i.e., better data efficiency)?
- •
Q3: Are the learned FM embeddings task-agnostic, and, if so, how much adaptation is needed to specialize them for specific tasks?

Figure: Figure 6: Effect of FM Model Size on Downstream Task Performance.
Refer to caption: downstream_vs_model_size.png

Figure: Figure 7: Larger FM is more data efficient.
Refer to caption: downstream_vs_data_size.png

Figure [6](https://arxiv.org/html/2508.14087v1#Sx5.F6) shows the downstream performance of all three tasks plotted against a pretrained FM size. All tasks use the same frozen pretrained representation. Larger pretrained models consistently yield higher performance across every task, confirming that scaling up the pretrained model size improves on various downstream performance even when only the lightweight decoder head is trained.

Figure [7](https://arxiv.org/html/2508.14087v1#Sx5.F7) depicts the ARI for the track finding task training on different number of labeled data, from 100 to 70,000. Larger FMs consistently outperform smaller ones across different levels of labeled data, indicating neural embeddings extracted from larger FMs contain richer information and can be generalized easier. This confirms common empirical observations that larger models can generalize better (Novak et al. [2018](https://arxiv.org/html/2508.14087v1#biba.bib34)). In addition, compared to a baseline adapter-only model trained solely on labeled data (dashed line in Figure [7](https://arxiv.org/html/2508.14087v1#Sx5.F7)), pretraining a self-supervised FM model on a large amount of unlabeled data – easy to come by in NPP – proves quite effective. The relative gain in ARI is greater in the fewer labeled data regions compared to those with abundant labeled data: $2.9\times$ versus $1.3\times$.

Figure: Figure 8: Visualization of learned embeddings from the FM (left) and the post-linear map features (right), projected via PCA reduction. Each marker corresponds to a spacepoint, colored by its associated track identity.
Refer to caption: x5.png

We analyze the neural embeddings from the frozen FM and their transformation after a simple linear projection, which precedes the lightweight adapter used for downstream tasks.
To assess the task specificity of these features, we apply dimensionality reduction techniques (e.g., PCA) to both the raw FM embeddings and linearly projected features, focusing on a representative downstream task: track finding.
As shown in Figure [8](https://arxiv.org/html/2508.14087v1#Sx5.F8), the raw FM embeddings exhibit no clear separation among particle tracks, indicating the representations are task-agnostic. However, after applying a single linear projection, distinct and well-separated clusters emerge, corresponding to different particle tracks.
This finding indicates the FM encodes rich, general-purpose representations that require minimal adaptation for task-specific use. It also explains why lightweight adapters, when built atop FM embeddings, outperform non-FM baselines by leveraging semantically meaningful input features.
Additional analyses are provided in Appendix C.

## Conclusion and Future Work

With this work, we demonstrate that FMs can be effectively extended to experimental particle physics by introducing a scalable self-supervised training strategy tailored to sparse detector data. Our model, trained on more than 11 million events, generalizes across diverse downstream tasks with frozen weights and lightweight adapters, consistently outperforming task-specific baselines. Its effective performance and data efficiency suggest the model learns rich, task-agnostic representations that are easily adapted using simple mappings. These findings reveal the potential for general-purpose, scalable models in NPP.

Future work will explore scaling behavior in greater depth by investigating larger models, larger datasets, and increased computational budgets, as well as alternative architectures. It may also be valuable to extend the FM paradigm to incorporate supervised fine-tuning jointly across multiple downstream tasks.
On the application side, incorporating additional detector subsystems—such as calorimeters and silicon trackers—could enable broader downstream tasks, including particle-flow reconstruction and rare event tagging (Paganini [2018](https://arxiv.org/html/2508.14087v1#biba.bib36)).
Another open question is whether the FM paradigm can generalize to heavy-ion collisions or be unified across multiple collider experiments worldwide.

## Acknowledgments

The authors would like to express their sincere gratitude to the sPHENIX Collaboration for sharing the simulation data and experimental knowledge, as well as Jubin Choi, Abhay Deshpande, Alexei Klimentov, Michael Begel, Torre Wenaus, Nicholas D’Imperio, James Dunlop, and John Hill from Brookhaven National Lab for their valuable support and feedback.

This work was supported by the Laboratory Directed Research and Development (LDRD) Program at Brookhaven National Laboratory, LDRD 25-045, which is operated and managed for the U.S. Department of Energy (DOE) Office of Science by Brookhaven Science Associates under contract No. DE-SC0012704.
Shuhang Li was partially supported by the DOE Office of Science through the Office of Nuclear Physics under Award No. DE‐FG02‐86ER40281.
Yihui Ren, Xihaier Luo and Shinjae Yoo were partially supported by the DOE Office of Science through the Office of Advanced Scientific Computing Research and the Scientific Discovery through Advanced Computing (SciDAC) program.

This research also utilized resources of the National Energy Research Scientific Computing Center (NERSC), a DOE Office of Science User Facility, under NERSC Award No. DDRERCAP-m4722. The authors are grateful to the NERSC staff for their support, particularly Shashank Subramanian and Wahid Bhimji.

## References

- Agostinelli et al. (2003)
Agostinelli, S.; et al. 2003.
GEANT4 - A Simulation Toolkit.
*Nucl. Instrum. Meth. A*, 506: 250–303.
- Aguilar et al. (2022)
Aguilar, M. R.; Chang, Z.; Elayavalli, R. K.; Fatemi, R.; He, Y.; Ji, Y.;
Kalinkin, D.; Kelsey, M.; Mooney, I.; and Verkest, V. 2022.
pythia8 underlying event tune for RHIC energies.
*Phys. Rev. D*, 105(1): 016011.
- Amrouche et al. (2020)
Amrouche, S.; Basara, L.; Calafiura, P.; Estrade, V.; Farrell, S.; Ferreira,
D. R.; Finnie, L.; Finnie, N.; Germain, C.; Gligorov, V. V.; Golling, T.;
Gorbunov, S.; Gray, H.; Guyon, I.; Hushchyn, M.; Innocente, V.; Kiehn, M.;
Moyse, E.; Puget, J.-F.; Reina, Y.; Rousseau, D.; Salzburger, A.;
Ustyuzhanin, A.; Vlimant, J.-R.; Wind, J. S.; Xylouris, T.; and Yilmaz, Y.
2020.
The Tracking Machine Learning Challenge: Accuracy Phase.
In Escalera, S.; and Herbrich, R., eds., *The NeurIPS ’18
Competition*, 231–264. Cham: Springer International Publishing.
- Battaglia et al. (2016)
Battaglia, P.; Pascanu, R.; Lai, M.; Jimenez Rezende, D.; et al. 2016.
Interaction networks for learning about objects, relations and
physics.
*Advances in neural information processing systems*, 29.
- Belmont et al. (2024)
Belmont, R.; et al. 2024.
Predictions for the sPHENIX physics program.
*Nucl. Phys. A*, 1043: 122821.
- Bodnar et al. (2025)
Bodnar, C.; Bruinsma, W. P.; Lucic, A.; Stanley, M.; Allen, A.; Brandstetter,
J.; Garvan, P.; Riechert, M.; Weyn, J. A.; Dong, H.; et al. 2025.
A foundation model for the Earth system.
*Nature*, 1–8.
- Bommasani et al. (2021)
Bommasani, R.; Hudson, D. A.; Adeli, E.; Altman, R.; Arora, S.; von Arx, S.;
Bernstein, M. S.; Bohg, J.; Bosselut, A.; Brunskill, E.; et al. 2021.
On the opportunities and risks of foundation models.
*arXiv preprint arXiv:2108.07258*.
- Brookhaven National Laboratory (2025)
Brookhaven National Laboratory. 2025.
sPHENIX Detector at RHIC.
https://www.bnl.gov/rhic/sphenix.php.
Accessed: 2025-07-19.
- Busza, Rajagopal, and van der Schee (2018)
Busza, W.; Rajagopal, K.; and van der Schee, W. 2018.
Heavy Ion Collisions: The Big Picture, and the Big Questions.
*Ann. Rev. Nucl. Part. Sci.*, 68: 339–376.
- Calafiura et al. (2024)
Calafiura, P.; Chan, J.; Delabrouille, L.; and Wang, B. 2024.
EggNet: An Evolving Graph-based Graph Attention Network for Particle
Track Reconstruction.
arXiv:2407.13925.
- Calafiura et al. (2018)
Calafiura, P.; Farrell, S.; Gray, H.; Vlimant, J.-R.; Innocente, V.;
Salzburger, A.; Amrouche, S.; Golling, T.; Kiehn, M.; Estrade, V.; Germaint,
C.; Guyon, I.; Moyse, E.; Rousseau, D.; Yilmaz, Y.; Gligorov, V. V.;
Hushchyn, M.; and Ustyuzhanin, A. 2018.
TrackML: A High Energy Physics Particle Tracking Challenge.
In *2018 IEEE 14th International Conference on e-Science
(e-Science)*, 344–344.
- Cheng et al. (2022)
Cheng, B.; Misra, I.; Schwing, A. G.; Kirillov, A.; and Girdhar, R. 2022.
Masked-attention Mask Transformer for Universal Image Segmentation.
arXiv:2112.01527.
- Cheng, Schwing, and Kirillov (2021)
Cheng, B.; Schwing, A. G.; and Kirillov, A. 2021.
Per-Pixel Classification is Not All You Need for Semantic
Segmentation.
arXiv:2107.06278.
- Collaboration, Aad et al. (2012)
Collaboration, A.; Aad, G.; et al. 2012.
Observation of a New Particle in the Search for the Standard Model
Higgs Boson with the ATLAS Detector at the LHC.
*Physics Letters B*, 716(1): 1–29.
- Dao and Gu (2024)
Dao, T.; and Gu, A. 2024.
Transformers are SSMs: Generalized Models and Efficient Algorithms
Through Structured State Space Duality.
In *Forty-first International Conference on Machine Learning*.
- Dosovitskiy et al. (2021)
Dosovitskiy, A.; Beyer, L.; Kolesnikov, A.; Weissenborn, D.; Zhai, X.;
Unterthiner, T.; Dehghani, M.; Minderer, M.; Heigold, G.; Gelly, S.;
Uszkoreit, J.; and Houlsby, N. 2021.
An Image is Worth 16x16 Words: Transformers for Image Recognition at
Scale.
In *International Conference on Learning Representations*.
- Fedus, Zoph, and Shazeer (2022)
Fedus, W.; Zoph, B.; and Shazeer, N. 2022.
Switch transformers: Scaling to trillion parameter models with simple
and efficient sparsity.
*Journal of Machine Learning Research*, 23(120): 1–39.
- Gu and Dao (2023)
Gu, A.; and Dao, T. 2023.
Mamba: Linear-time sequence modeling with selective state spaces.
*arXiv preprint arXiv:2312.00752*.
- Gu and Dao (2024)
Gu, A.; and Dao, T. 2024.
Mamba: Linear-Time Sequence Modeling with Selective State Spaces.
In *First Conference on Language Modeling*.
- Hoffmann et al. (2022)
Hoffmann, J.; Borgeaud, S.; Mensch, A.; Buchatskaya, E.; Cai, T.; Rutherford,
E.; Casas, D. d. L.; Hendricks, L. A.; Welbl, J.; Clark, A.; et al. 2022.
Training compute-optimal large language models.
*arXiv preprint arXiv:2203.15556*.
- Hubert and Arabie (1985)
Hubert, L.; and Arabie, P. 1985.
Comparing partitions.
*Journal of Classification*, 2(1): 193–218.
- Jiang and Qian (2025)
Jiang, C.; and Qian, S. 2025.
Application of Structured State Space Models to High energy physics
with locality sensitive hashing.
In *International Conference on Artificial Intelligence and
Statistics*, 3961–3969. PMLR.
- Ju et al. (2021)
Ju, X.; Murnane, D.; Calafiura, P.; Choma, N.; Conlon, S.; Farrell, S.; Xu, Y.;
Spiropulu, M.; Vlimant, J.-R.; Aurisano, A.; Hewes, J.; Cerati, G.; Gray, L.;
Klijnsma, T.; Kowalkowski, J.; Atkinson, M.; Neubauer, M.; DeZoort, G.;
Thais, S.; Chauhan, A.; Schuy, A.; Hsu, S.-C.; Ballow, A.; and Lazar, A.
2021.
Performance of a geometric deep learning pipeline for HL-LHC particle
tracking.
*The European Physical Journal C*, 81(10).
- Kalman (1960)
Kalman, R. E. 1960.
A New Approach to Linear Filtering and Prediction Problems.
*Journal of Basic Engineering*, 82(1): 35–45.
- Kaplan et al. (2020)
Kaplan, J.; McCandlish, S.; Henighan, T.; Brown, T. B.; Chess, B.; Child, R.;
Gray, S.; Radford, A.; Wu, J.; and Amodei, D. 2020.
Scaling laws for neural language models.
*arXiv preprint arXiv:2001.08361*.
- Klest (2020)
Klest, H. 2020.
Overview and design of the sPHENIX TPC.
*J. Phys. Conf. Ser.*, 1498: 012025.
- Kolodiazhnyi et al. (2024)
Kolodiazhnyi, M.; Vorontsova, A.; Konushin, A.; and Rukhovich, D. 2024.
Oneformer3d: One transformer for unified point cloud segmentation.
In *Proceedings of the IEEE/CVF Conference on Computer Vision
and Pattern Recognition*, 20943–20953.
- Li et al. (2024)
Li, Q.; Hu, Z.; Wang, Y.; Li, L.; Fan, Y.; King, I.; Song, L.; and Li, Y. 2024.
Progress and Opportunities of Foundation Models in Bioinformatics.
*Briefings in Bioinformatics*.
Survey of foundation models in bioinformatics.
- Loshchilov and Hutter (2017)
Loshchilov, I.; and Hutter, F. 2017.
Decoupled weight decay regularization.
*arXiv preprint arXiv:1711.05101*.
- Ma et al. (2024)
Ma, Q.; Jiang, Y.; Cheng, H.; and Xu, D. 2024.
Harnessing the deep learning power of foundation models in
single-cell omics.
*Nature Reviews Molecular Cell Biology*, 25(8): 593–594.
- Mildenhall et al. (2021)
Mildenhall, B.; Srinivasan, P. P.; Tancik, M.; Barron, J. T.; Ramamoorthi, R.;
and Ng, R. 2021.
Nerf: Representing scenes as neural radiance fields for view
synthesis.
*Communications of the ACM*, 65(1): 99–106.
- Moskowitz (2023)
Moskowitz, C. 2023.
Tiny Bubbles of Primordial Soup Re‑create Early Universe.
*Scientific American*, 328(3).
Accessed: 2025‑07‑19.
- Nguyen et al. (2023)
Nguyen, T.; Brandstetter, J.; Kapoor, A.; Gupta, J. K.; and Grover, A. 2023.
ClimaX: a25 foundation model for weather and climate.
In *Proceedings of the 40th International Conference on Machine
Learning*, ICML’23. JMLR.org.
- Novak et al. (2018)
Novak, R.; Bahri, Y.; Abolafia, D. A.; Pennington, J.; and Sohl-Dickstein, J.
2018.
Sensitivity and Generalization in Neural Networks: an Empirical
Study.
In *International Conference on Learning Representations*.
- Osborn et al. (2021)
Osborn, J. D.; Frawley, A. D.; Huang, J.; Lee, S.; Da Costa, H. P.; Peters, M.;
Pinkenburg, C.; Roland, C.; and Yu, H. 2021.
Implementation of ACTS into sPHENIX Track Reconstruction.
*Comput. Softw. Big Sci.*, 5(1): 23.
- Paganini (2018)
Paganini, M. 2018.
Machine Learning Algorithms for $b$-Jet Tagging at the ATLAS
Experiment.
*J. Phys. Conf. Ser.*, 1085(4): 042031.
- Pyzer-Knapp et al. (2025a)
Pyzer-Knapp, E. O.; Manica, M.; Staar, P.; Morin, L.; Ruch, P.; Laino, T.;
Smith, J. R.; and Curioni, A. 2025a.
Foundation models for materials discovery–current state and future
directions.
*Npj Computational Materials*, 11(1): 61.
- Pyzer-Knapp et al. (2025b)
Pyzer-Knapp, E. O.; Manica, M.; Staar, P.; Morin, L.; Ruch, P.; Laino, T.;
Smith, J. R.; and Curioni, A. 2025b.
Foundation models for materials discovery – current state and
future directions.
*npj Computational Materials*, 11: 15.
- Qasim et al. (2019)
Qasim, S. R.; Kieseler, J.; Iiyama, Y.; and Pierini, M. 2019.
Learning representations of irregular particle-detector geometry with
distance-weighted graph networks.
*The European Physical Journal C*, 79(7): 1–11.
- Rusch, Bronstein, and Mishra (2023)
Rusch, T. K.; Bronstein, M. M.; and Mishra, S. 2023.
A survey on oversmoothing in graph neural networks.
*arXiv preprint arXiv:2303.10993*.
- Sjöstrand et al. (2015)
Sjöstrand, T.; Ask, S.; Christiansen, J. R.; Corke, R.; Desai, N.; Ilten, P.;
Mrenna, S.; Prestel, S.; Rasmussen, C. O.; and Skands, P. Z. 2015.
An introduction to PYTHIA 8.2.
*Comput. Phys. Commun.*, 191: 159–177.
- sPHENIX Collaboration (2025a)
sPHENIX Collaboration. 2025a.
acts: A common tracking software toolkit for sPHENIX, tagged at
33fc284f238a24405bcd6c2de3260f370d6f8403.
https://github.com/sPHENIX-Collaboration/acts/tree/33fc284f238a24405bcd6c2de3260f370d6f8403.
Accessed August 3, 2025; part of the official sPHENIX build
environment.
- sPHENIX Collaboration (2025b)
sPHENIX Collaboration. 2025b.
calibrations: Calibration code for sPHENIX, tagged at
a3e66e69635514813ee3e20bf18b2bd59787b503.
https://github.com/sPHENIX-Collaboration/calibrations/tree/a3e66e69635514813ee3e20bf18b2bd59787b503.
Accessed August 3, 2025; part of the official sPHENIX build
environment.
- sPHENIX Collaboration (2025c)
sPHENIX Collaboration. 2025c.
coresoftware: Core simulation and reconstruction software for the
sPHENIX experiment, tagged at
b849eba5c2cf8ada510d036aa9b9499cb31f0513.
https://github.com/sPHENIX-Collaboration/coresoftware/tree/b849eba5c2cf8ada510d036aa9b9499cb31f0513.
Accessed August 3, 2025; used in the official sPHENIX build,
including downstream emulation and reconstruction.
- sPHENIX Collaboration (2025d)
sPHENIX Collaboration. 2025d.
macros: Analysis and utility macros for sPHENIX, tagged at
661f781db23352a3fa72055ce7dbf1a0ee1c2167.
https://github.com/sPHENIX-Collaboration/macros/tree/661f781db23352a3fa72055ce7dbf1a0ee1c2167.
Accessed August 3, 2025; part of the official sPHENIX build
environment.
- Stroud et al. (2024)
Stroud, S. V.; Duckett, P.; Hart, M.; Pond, N.; Rettie, S.; Facini, G.; and
Scanlon, T. 2024.
Transformers for Charged Particle Track Reconstruction in High Energy
Physics.
arXiv:2411.07149.
- Vankadara et al. (2024)
Vankadara, L. C.; Xu, J.; Haas, M.; and Cevher, V. 2024.
On feature learning in structured state space models.
In *The Thirty-eighth Annual Conference on Neural Information
Processing Systems*.
- Vaswani et al. (2017)
Vaswani, A.; Shazeer, N.; Parmar, N.; Uszkoreit, J.; Jones, L.; Gomez, A. N.;
Kaiser, Ł.; and Polosukhin, I. 2017.
Attention is all you need.
*Advances in neural information processing systems*, 30.
- Wang et al. (2023)
Wang, W.; Dai, J.; Chen, Z.; Huang, Z.; Li, Z.; Zhu, X.; Hu, X.; and et al.
2023.
InternImage: Exploring Large-Scale Vision Foundation Models With
Deformable Convolutions.
In *CVPR 2023*, 3591–3600.
- Yang et al. (2022)
Yang, G.; Hu, E. J.; Babuschkin, I.; Sidor, S.; Liu, X.; Farhi, D.; Ryder, N.;
Pachocki, J.; Chen, W.; and Gao, J. 2022.
Tensor programs v: Tuning large neural networks via zero-shot
hyperparameter transfer.
*arXiv preprint arXiv:2203.03466*.
- Zhou et al. (2023)
Zhou, Y.; Chia, M. A.; Wagner, S. K.; Ayhan, M. S.; Williamson, D. J.;
Struyven, R. R.; Liu, T.; Xu, M.; Lozano, M. G.; Woodward-Court, P.; et al.
2023.
A foundation model for generalizable disease detection from retinal
images.
*Nature*, 622(7981): 156–163.

## Appendix A Dataset

The dataset used in this work is based on simulated proton–proton (p+p) collisions at center‑of‑mass energy of $\sqrt{s}=200\,$GeV, corresponding to the conditions of the sPHENIX experiment at the Relativistic Heavy Ion Collider (RHIC), where charged-particle trajectories are recorded with the Time Projection Chamber (TPC). p+p collisions serve as a precision workhorse for testing QCD and nucleon structure and provide the baseline for quantifying how particle production in heavy‑ion collisions, viewed as a superposition of pp interactions, is modified by the QGP (Busza, Rajagopal, and van der Schee [2018](https://arxiv.org/html/2508.14087v1#biba.bib9)).

Figure: Figure 9: Relativistic Heavy Ion Collider at Brookhaven National Lab and sPHENIX Experiment.
Refer to caption: x6.png

### Simulation and Provenance

Minimum‑bias p+p collisions are generated with pythia-8.307 (Sjöstrand et al. [2015](https://arxiv.org/html/2508.14087v1#biba.bib41)) ‘Detroit’ tune (Aguilar et al. [2022](https://arxiv.org/html/2508.14087v1#biba.bib2)), and then propagated through a full Geant4 (Agostinelli et al. [2003](https://arxiv.org/html/2508.14087v1#biba.bib1)) simulation of the as‑built sPHENIX detector, including its detailed CAD geometry and measured $1.4$T field map. We employ the ‘FTFP_BERT_HP’ physics list for high‑precision treatment of neutron and hadron interactions. The simulation chain models continuous energy loss, multiple scattering, secondary particle production, and decay processes with the true material budget, supports space‑charge distortion and its data‑driven correction, and carries signals through the full front‑end electronics (shaping, digitization, zero suppression, and channel‑by‑channel gain/noise).

The simulated TPC response, so‑called G4Hits, emulates raw ionization signals from charged particles traversing the TPC volume, which are reconstructed into spacepoints reflecting the true spatial resolution and distortions. Each spacepoint is then matched to the Monte Carlo truth particle that produced it, and the particle’s properties—identity, momentum, and track association—are recorded as ground‑truth labels for our downstream tasks (track finding, PID, and noise identification).

All of the code used to drive the pythia-8 and Geant4 simulations, as well as the downstream emulation and reconstruction chain (digitization, spacepoint reconstruction), is sourced from the sPHENIX software stack, including the core simulation and reconstruction libraries and supporting infrastructure (sPHENIX Collaboration [2025c](https://arxiv.org/html/2508.14087v1#biba.bib44), [a](https://arxiv.org/html/2508.14087v1#biba.bib42), [d](https://arxiv.org/html/2508.14087v1#biba.bib45), [b](https://arxiv.org/html/2508.14087v1#biba.bib43)).

### Contents and Structure

Each event contains:

- •
Reconstructed spacepoints from the TPC, including position and ionization energy.
- •
Monte Carlo truth particles with their PDG identity, momentum at production, and vertex location at production.
- •
Associations between spacepoints and truth particles.

### Dataset Statistics

The event-level complexity in the dataset varies widely. As shown in Fig [10](https://arxiv.org/html/2508.14087v1#A1.F10), the number of reconstructed TPC spacepoints per event ranges from a few hundred to tens of thousands, reflecting low-multiplicity to relatively busy collision topologies. Correspondingly, the number of truth tracks per event spans from under ten up to nearly one hundred.

Figure [11](https://arxiv.org/html/2508.14087v1#A1.F11) summarizes the class composition for the noise-tagging and particle identification (PID) downstream tasks.

Figure: Figure 10: Distributions of number of spacepoints and tracks per event.
Refer to caption: x7.png

##### Noise-tagging.

Noise spacepoints are defined operationally based on the truth-level kinematics of their progenitor particles.
Specifically, any spacepoint associated with a Monte Carlo truth track whose momentum is below $60\ \mathrm{MeV}/c$ is labeled as noise.
Particles produced in the primary p+p collision with such low momentum are kinematically unable to reach the active TPC volume due to the magnetic field; therefore, spacepoints matched to these low-momentum tracks arise predominantly from secondary interactions with detector material (e.g., delta electrons, conversion products, or other material-induced processes).
These secondary-origin spacepoints are not part of the primary signal topology of interest and are treated as “noise” for the purposes of the corresponding downstream classification task.

##### PID.

Figure: Figure 11: Class ratio of noise tagging and particle identification.
Refer to caption: x8.png

The PID task uses five coarse-grained target classes, grouping charge-conjugate species together to reduce sparsity while preserving physics relevance:

- •
Pion: $\pi^{+}$, $\pi^{-}$
- •
Kaon: $K^{+}$, $K^{-}$
- •
Proton: proton and anti-proton
- •
Electron: electron and positron
- •
Other: all remaining particle species

The class ratios shown in Fig. [11](https://arxiv.org/html/2508.14087v1#A1.F11) reflect the inherent imbalance in these labels, driven by the underlying particle production spectra and the noise definition.

## Appendix B Methodology

### Preliminaries

This section outlines a compact mathematical way to express the hierarchical relationship between events, tracks, and spacepoints in a particle detector like a Time Projection Chamber (TPC). A collision event $E$ is represented as a set of tracks $\{T_{j}\}$, where each track $T_{j}$ is an ordered sequence of spacepoints $(s_{k})$, and each spacepoint $s$ is a vector $(E_{\text{dep}},x,y,z,\dots)$ containing its physical properties. Concretely, we express a single event, $E$, as follows:

$$ $E=\{T_{j}\}_{j=1}^{m}$ $$

This states that an event ($E$) is a set containing $m$ individual tracks ($T_{j}$). The number of tracks, $m$, is variable for each event. Each track, in turn, is defined by its constituent spacepoints:

$$ $T_{j}=(s_{j,k})_{k=1}^{n_{j}}$ $$

This expresses that a single track ($T_{j}$) is an ordered sequence of $n_{j}$ spacepoints ($s_{j,k}$). The sequence is ordered because particles follow a specific path through the detector, and the number of spacepoints per track, $n_{j}$, is also variable. Finally, each individual spacepoint is a vector of its properties, which can be represented abstractly as:

$$ $s_{j,k}\in\mathbb{R}^{D}$ $$

A spacepoint ($s$) is a vector in a D-dimensional feature space. A Spacepoint ($s_{j,k}$) is now explicitly defined as a vector containing its primary physical properties:

$$ $s_{j,k}=(\mathcal{E},x,y,z)_{j,k}$ $$

where $\mathcal{E}$ is the energy deposited by the particle at that point in the detector, and $(x,y,z)$ is the spatial coordinates of the spacepoint.

### Coordinate Transformation

We transform spacepoint coordinates from Cartesian $(x,y,z)$ to a cylindrical-polar system $(r,\phi,\eta)$ that better reflects the geometry and symmetries of collider experiments. The radial distance $r$ is defined as $r=\sqrt{x^{2}+y^{2}}$, measuring how far a point lies from the beamline in the transverse plane, and is essential for evaluating transverse momentum and energy. The azimuthal angle $\phi$ is given by $\phi=\operatorname{atan2}(y,x)$, describing the orientation of the spacepoint in the $x$-$y$ plane and exploiting the detector’s cylindrical symmetry around the beam axis. The pseudorapidity $\eta$ is defined as $\eta=-\ln\left[\tan\left(\theta/2\right)\right]$, where $\theta=\operatorname{atan2}(r,z)$ is the polar angle; this coordinate is used instead of $\theta$ because particle production tends to be uniform in $\eta$, and for highly relativistic particles, $\eta$ approximates the Lorentz-invariant rapidity. Finally, to ensure consistent feature scaling, we apply a min-max normalization to the spatial coordinates, transforming the pseudorapidity ($\eta\in[-2,2]$), azimuthal angle ($\phi\in[-\pi,\pi]$), and radial distance ($r\in[30,78]$, centimeters) into the interval $[0,1]$. The transformed $s_{i}=(\mathcal{E},r,\phi,\eta)_{i}$ are used for all analyses described in this paper.

### Serialization

Our objective is to perform self-supervised pretraining on the raw 3D point cloud of particle spacepoints from a collision event, $S=\{s_{1},\dots,s_{N}\}$. To leverage the power of sequential models like MAMBA, which have excelled in learning rich representations, we must first solve the fundamental problem of transforming the unordered 3D set into an ordered 1D sequence. This serialization process is not merely a technical step; the choice of ordering scheme is critical to preserving the underlying physical structure of the data.

An ideal serialization must satisfy two competing demands: it must respect the global physics of the event (i.e., particles flying outwards) while simultaneously preserving the local continuity of individual particle tracks.

We first analyze and dismiss naive approaches. A space-filling curve, for example, excels at preserving 3D locality but completely disregards the concept of a track; its path erratically jumps between physically distinct trajectories, creating a chaotic signal. Conversely, a simple global raster scan on the spacepoints’ cylindrical coordinates, $s^{\prime}_{i}=(r_{i},\phi_{i},\eta_{i})$, respects the outward propagation along the radius but fails on local continuity. The initial hits of a track (at low $r$) become “context-starved,” as their preceding elements in the sequence belong to entirely different tracks.

##### Proposed Solution: Hierarchical Raster Scan

To resolve this dichotomy, we introduce a Hierarchical Raster Scan. This method balances global structure with local context by operating on two levels:

- 1.
Partitioning: The entire detector volume is partitioned into a grid of smaller 3D “boxes.”
- 2.
Ordering: A raster scan using the physically-motivated order $(r,\phi,\eta)$ is applied twice. First, it orders the spacepoints within each box (intra-box ordering). Second, it orders the boxes themselves based on their geometric centers (inter-box ordering).

This strategy ensures that the sequence progresses globally outwards but maintains local contiguity within each partitioned region. However, even with this optimal serialization, a profound challenge remains. If the learning objective were to simply predict the next hit in this sequence, the model would be forced to learn the arbitrary artifacts of the serialization itself, particularly the artificial jumps at box boundaries.

Therefore, designing a robust serialization scheme is a necessary but insufficient step. The learning objective must be intelligently designed to be independent of these serialization artifacts, a challenge we address in the subsequent section.

##### Physics Informed Partitioning

The division of the detector volume into a grid is not uniform; it is a physics-informed partitioning designed to align with both the detector’s physical geometry and the observed distribution of particle hits. This ensures the partitioning itself provides a meaningful structural prior for the learning task.

For the azimuthal angle ($\phi$) and pseudorapidity ($\eta$) dimensions, the binning is data-driven. The boundaries are specifically chosen to create bins with a roughly uniform density of hits. This strategy balances the information content across partitions, preventing high-occupancy regions from disproportionately influencing the model. A detailed number of bins and illustration of this binning strategy is provided in Figure [12](https://arxiv.org/html/2508.14087v1#A2.F12).

Figure: Figure 12: Physics Informed Partitioning. Top-left graph shows the binning of the data space into 384 bins ($8\times 8\times 6$). The other plots show the distribution of spacepoint values in normalized Phi, Eta, and Radius dimensions, respectively, computed using 50,000 events.
Refer to caption: voxelize_appendix.png

For the radial dimension ($r$), the partitioning mirrors the physical construction of the sPHENIX detector. The detector’s 48 layers are arranged in three major groups; therefore, we create six radial bins, allocating two bins to each major detector group. By embedding the detector’s known layered structure into the partitioning scheme, we further ground the serialization process in the experiment’s physical reality.

### MAMBA: Selective State Space Models

Mamba represents a significant advancement in sequence modeling, challenging the dominance of the Transformer architecture, particularly for long sequences. It is a selective state space model (SSM) that combines the strengths of recurrent neural networks (RNNs) and convolutional neural networks (CNNs) to offer linear-time complexity and constant-time inference.

Mamba’s foundation is the State Space Model, a continuous-time system described by the following linear ordinary differential equation:

$$ $\displaystyle\frac{dh(t)}{dt}$ $\displaystyle=Ah(t)+Bx(t),$ $\displaystyle y(t)$ $\displaystyle=Ch(t)+Dx(t)$ $$

Here, $h(t)$ is the latent state, $x(t)$ is the input, and $y(t)$ is the output. $A$, $B$, $C$, and $D$ are matrices that are typically learned from data.

For use in deep learning, this continuous system is discretized. A crucial step in Mamba is making the key matrices, particularly the transition matrix $A$ and the input projection matrix $B$, selective and input-dependent. This is achieved by having dedicated neural networks that predict these matrices based on the current input token.

The discretized formulation of the state transition is:

$$ $h_{t}=\bar{A}h_{t-1}+\bar{B}x_{t}$ (1) $$

Where $\bar{A}$ and $\bar{B}$ are the discretized, input-dependent matrices. This selectivity allows Mamba to modulate its recurrent state, effectively controlling how much of the past to retain and how to incorporate the current input. The model can be unrolled for efficient parallel training, similar to a CNN, or used in a recurrent manner for constant-time inference.

##### Architectural Principles

The core innovation of Mamba lies in its selective mechanism, which allows the model to dynamically adapt its parameters based on the input. This enables it to focus on relevant information and filter out noise, a crucial capability for processing long and complex sequences. Unlike traditional SSMs, which are time-invariant, Mamba’s parameters are functions of the input, making it a time-varying system. Key components of the Mamba architecture include:

- •
Selective State Space Layer: This is the fundamental building block of Mamba. It replaces the attention mechanism and feed-forward network of a Transformer block.
- •
Hardware-Aware Algorithm: Mamba employs a parallel scan algorithm that is optimized for modern hardware (GPUs), enabling efficient training and inference. This algorithm avoids the materialization of the full state sequence, a significant memory bottleneck in traditional SSMs.

##### Mamba2

Mamba2 is a direct successor to Mamba, designed to further improve upon its efficiency and performance. It introduces a new theoretical framework called Structured State Space Duality (SSD), which provides a deeper understanding of the relationship between SSMs and other architectures like Transformers. The primary motivation behind Mamba-2 was to address some of the hardware utilization inefficiencies of the original Mamba. While Mamba offered linear-time complexity, its performance on modern GPUs could still be optimized. Key improvements in Mamba-2 include:

- •
State Space Duality (SSD): This framework establishes a formal equivalence between a class of structured SSMs and a form of global convolution. This duality allows for the design of more efficient algorithms by leveraging insights from both perspectives.
- •
Architectural Simplifications: Mamba-2 simplifies the Mamba block by replacing the complex selective scan with a more structured and hardware-friendly formulation derived from the SSD framework. This often involves a multi-headed Mamba block, analogous to the multi-head attention in Transformers.
- •
Improved Hardware Utilization: The redesigned architecture of Mamba-2 is more amenable to parallelization on modern hardware, leading to significant speedups in both training and inference compared to the original Mamba.

### FM4NPP: Architecture

##### Positional Embedding

The model first transforms the raw input data into a high-dimensional space suitable for sequence processing. An input batch of serialized collision events is represented as a tensor of shape $(B,S,4)$, where B is the batch size, S is the sequence length, and each spacepoint is a 4-dimensional vector comprising its deposited energy and 3D spatial coordinates $(E_{\text{dep}},\eta,\phi,r)$. This tensor is processed by an embedding module that projects the 4D spacepoint features into the model’s latent space, $D_{\text{model}}$. It also computes a positional encoding from the 3D spatial coordinates using a function $\gamma(\cdot)$ inspired by Neural Radiance Fields (NeRF), defined as:

$$ $\gamma(\mathbf{p})=\left(\mathbf{p},\sin(2\mathbf{p}),\cos(2\mathbf{p}),\dots,\sin(2^{l}\mathbf{p}),\cos(2^{l}\mathbf{p})\right)$ $$

where $\mathbf{p}$ is the coordinate vector and the frequencies $2^{l}$ are sampled from a geometric progression. This encoding, also mapped to $D_{\text{model}}$, is combined with the feature representation via element-wise addition. The output of this stage is a single tensor of shape $(B,S,D_{\text{model}})$, where $D_{\text{model}}$ is the model width.

##### Network Architecture and k-Next Nearest Neighbor Prediction Head

The core architecture consists of a stack of Mamba blocks that sequentially process the embedded hits. The input to the first block is the $(B,S,D_{\text{model}})$ tensor from the embedding stage. Each block operates as follows:

- •
Pre-Normalization: The input tensor is first passed through a Root Mean Square Normalization (RMSNorm) layer. This layer normalizes the feature vector of each spacepoint independently.
- •
Sequence Modeling: The normalized $(B,S,D_{\text{model}})$ tensor is then processed by the Mamba2 layer.
- •
Residual Connection: A residual or “skip” connection is applied around the normalization and Mamba2 layers. The original input to the block is added element-wise to the output of the Mamba2 layer.

After passing through the final Mamba block, the sequence is processed by one last RMSNorm layer. The resulting $(B,S,D_{\text{model}})$ tensor is then fed into the prediction head. This head is a single linear layer that projects the $D_{\text{model}}$-dimensional representation of each hit to a $3k$-dimensional vector, yielding a final output tensor of shape $(B,S,3k)$. Here, $k=10$ is the number of neighbors to be predicted. This output format is designed specifically for the Causal k-Nearest Neighbor (kNN) objective.

### Maximal Update Parameterization

##### Challenge in Scaling Models

Imagine building with LEGOs. If you build a small car, it’s stable. But if you try to build a life-sized car using the exact same small-brick techniques, it will be flimsy and fall apart. Modern AI models face a similar problem. When we try to make them bigger and more powerful by adding more “width” or digital neurons, their internal mathematics can become unstable during training. The signals inside can either “explode” into uselessly large numbers or “vanish” to zero, making it impossible for the model to learn. µ-Parameterization (µP) is a groundbreaking set of rules that solves this problem. It’s like a master blueprint for building AI models, telling us exactly how to adjust the initial settings and the learning rate based on the model’s size. This ensures that as the model scales up, its internal signals stay perfectly balanced, allowing it to train stably and effectively. A major benefit is that the best training settings found on a small, cheap model can be directly transferred to a massive, expensive one, saving enormous amounts of time and computational cost.

Concretely, standard infinite-width network analyses, such as those based on the Neural Tangent Kernel (NTK), predict that wide networks operate in a “lazy regime” where they fail to learn meaningful features from data. µ-Parameterization (µP) was introduced to overcome this limitation by defining a specific scaling of model initializations and learning rates that guarantees non-trivial feature evolution in the infinite-width limit. A significant practical advantage of µP is that it enables zero-shot hyperparameter transfer, allowing optimal settings found on small-scale models to be directly applied to their large-scale counterparts. This mitigates the often prohibitive computational costs associated with tuning large models.

##### Applications in Modern Architectures

The principles of µP have been successfully extended beyond simple multi-layer perceptrons (MLPs) to a range of complex architectures. In Transformers, µP facilitates hyperparameter transfer, although achieving a stable feature-learning limit requires careful scaling with respect to both model width and depth. The framework has also been adapted for scientific machine learning models like Fourier Neural Operators (FNOs), where a specific µ-FNO parameterization ensures stable training as the model size and number of Fourier modes are scaled. More recently, µP has been applied to stabilize the training of large Diffusion Models, again enabling hyperparameter transfer for these computationally intensive generative systems. This body of research highlights both the generality of the µP framework and the necessity of deriving architecture-specific scaling laws.

##### µP for MAMBA

To address this, a corrected scaling for State Space Models (SSMs), termed $\mu$P-SSM (Maximal Update Parameterization for SSMs), was derived by analyzing signal propagation directly within the Mamba architecture. This analysis yielded specific scaling rules for initialization variances ($\sigma$), which control the scale of the model’s initial random weights, and learning rates ($\eta$), which determine the step size during training. The key formulas dictate how these parameters for Mamba’s weight matrices ($W_{B},W_{C}$) should be scaled relative to the model’s latent state dimension ($N_{x}$) and input dimension ($N_{u}$). Using asymptotic Big-Theta ($\Theta$) notation, the rules are:

- •
Initialization Variances: $\sigma_{B}\in\Theta(\sqrt{\frac{N_{x}}{N_{u}}})$ and $\sigma_{C}\in\Theta(\frac{1}{\sqrt{N_{x}N_{u}}})$
- •
Learning Rates: $\eta_{B}\in\Theta(\frac{N_{x}}{\sqrt{N_{u}}})$ and $\eta_{C}\in\Theta(\frac{1}{N_{x}\sqrt{N_{u}}})$

We have integrated this $\mu$P-SSM methodology into our own Mamba-based model. The effectiveness of this approach is evidenced by the stable scaling of layer-wise activation norms across different model sizes, as empirically verified in our experiments. Unlike standard parameterizations which lead to exploding signals or heuristic $\mu$P which leads to vanishing signals, our model’s activations and their updates remain correctly scaled, confirming that the model is operating in a stable feature-learning regime.

### Additional Details for Pretraining

The model is trained using the AdamW optimizer, which incorporates weight decay for regularization against overfitting. To manage the learning rate dynamics, we employ a cosine decay schedule, which is preceded by a brief linear warmup period at the beginning of training to ensure initial stability. To further prevent training instabilities arising from large gradients, we apply gradient clipping. The learning objective is to minimize a Mean Squared Error (MSE) loss function. This loss quantifies the Euclidean distance between the model’s predicted coordinates for the k-Nearest Neighbors (kNN) and the truth coordinates. These truth neighbors are pre-computed for each particle spacepoint during the data loading phase to ensure efficient throughput during training.

##### Loss Re-scaling by Event Difficulty

We identified a nuisance structure in the training data related to event spacepoint density; events with a larger number of spacepoints are inherently easier to predict, as the average distance between neighboring spacepoints is smaller. This variance in difficulty can lead to training instability, manifesting as loss spikes. To mitigate this, we introduce a loss re-scaling strategy based on event binning. Events are first grouped into discrete bins based on their average k-Nearest Neighbor (kNN) distance, which serves as a proxy for prediction difficulty. Let $g(i)$ be the function that maps event $i$ to its corresponding difficulty bin. The loss objective is then modified as follows: (1) the Mean Squared Error (MSE) for each event is re-weighted by a factor $w_{g(i)}$ corresponding to the average difficulty of its bin, and (2) the total batch loss is calculated by averaging these re-weighted individual losses. This is formulated as:

$$ $\mathcal{L}=\frac{1}{B}\sum_{i=1}^{B}w_{g(i)}\mathcal{L}_{i}=\frac{1}{B}\sum_{i=1}^{B}w_{g(i)}\left(\frac{1}{S_{n}}\sum_{j=1}^{S_{n}}||\mathbf{s}_{ij}-\mathbf{y}_{ij}||_{2}^{2}\right)$ $$

Here, $B$ is the number of events in the batch, $\mathcal{L}_{i}$ is the standard MSE for event $i$ with $S_{n}$ spacepoints, $\mathbf{s}_{ij}$ and $\mathbf{y}_{ij}$ are the predicted and truth coordinates respectively, and $w_{g(i)}$ is the pre-computed weight for the difficulty bin to which the event belongs. This ensures that a single batch-averaged loss is computed only after accounting for the inherent difficulty of each event in the batch.

## Appendix C Additional Results

### Downstream Model

#### Tracking (Instance Segmentation)

Our lightweight downstream model for track finding—formulated as a per-point instance segmentation task—is inspired by image panoptic segmentation models such as MaskFormer and Mask2Former, adapted to point cloud data.

Let $\mathbf{X}=\{\mathbf{x}_{i}\}_{i=1}^{N}$ denote the input set of $N$ points, where each $\mathbf{x}_{i}\in\mathbb{R}^{d}$ is a $d$-dimensional point-level feature (either raw input, pretrained representation, or from a randomly initialized encoder). These are first projected into a latent embedding space via a linear layer:

$$ $\mathbf{e}_{i}=\mathbf{W}_{\text{proj}}\mathbf{x}_{i},\quad\mathbf{e}_{i}\in\mathbb{R}^{d_{e}}.$ $$

We denote the set of projected spacepoint embeddings as $\mathbf{E}=\{\mathbf{e}_{i}\}_{i=1}^{N}$.

To represent candidate tracks, we use $K$ learnable queries (track queries) $\mathbf{Q}^{(0)}=\{\mathbf{q}_{k}^{(0)}\}_{k=1}^{K}$, where each $\mathbf{q}_{k}^{(0)}\in\mathbb{R}^{d_{e}}$. These prototypes are refined over $L$ transformer decoder layers. Each decoder layer consists of:

- •
Cross-attention: updates $\mathbf{q}_{k}$ by attending to point embeddings $\mathbf{E}$.
- •
Self-attention: refines interaction among the $K$ prototypes.
- •
Feed-forward network (FFN): standard transformer update.

After $L$ decoder layers, we obtain the refined track queries $\mathbf{Q}^{(L)}=\{\mathbf{q}_{k}^{(L)}\}_{k=1}^{K}$. Each refined query vector is then processed by two MLPs:

$$ $\mathbf{m}_{k}=\text{MLP}_{\text{mask}}(\mathbf{q}_{k}^{(L)}),\quad\hat{y}_{k}=\text{MLP}_{\text{cls}}(\mathbf{q}_{k}^{(L)}),$ $$

where $\mathbf{m}_{k}\in\mathbb{R}^{d_{e}}$ is the track embedding for the $k$-th prototype, and track instance prediction $\hat{y}_{k}\in[0,1]$ is the probability of corresponding to a real track (vs. a “no-object” class).

Each track embedding $\mathbf{m}_{k}$ is used to compute point-to-prototype assignment logits:

$$ $z_{ik}=\mathbf{e}_{i}^{\top}\mathbf{m}_{k},\quad\hat{p}_{ik}=\sigma(z_{ik}),$ $$

where $\sigma(\cdot)$ denotes the sigmoid function. The predicted assignment probability $\hat{p}_{ik}$ represents the likelihood that point $i$ belongs to prototype $k$.

To encourage each track query to focus on the subset of points it is likely responsible for, we apply an additive attention mask during cross-attention. The attention mask is defined as:

$$ $A_{ik}=-\log(\hat{p}_{ik}+\epsilon),$ $$

with a small constant $\epsilon$ added for numerical stability. This mask is added to the attention logits before the softmax operation in the cross-attention layer.
This dynamic masking suppresses contributions from low-probability points and improves localization by making each prototype attend selectively to its likely constituent points.

##### Training Loss.

Let $\mathcal{T}=\{T_{j}\}_{j=1}^{M}$ be the set of $M$ ground-truth tracks (instance labels). We compute a bipartite matching between the $M$ ground-truth tracks and the $K$ refined track queries using the Hungarian algorithm. The matching minimizes a cost function combining:

- •
Dice loss $\mathcal{L}_{\text{dice}}$ on the per-point predicted vs. ground-truth track,
- •
Focal loss $\mathcal{L}_{\text{focal}}$ on point-wise assignment probabilities,
- •
Classification loss $\mathcal{L}_{\text{cls}}$ on the track/no-object prediction.

For each matched pair $(T_{j},\mathbf{q}_{k})$, the total loss is:

$$ $\mathcal{L}_{\text{match}}^{(j,k)}=\lambda_{\text{dice}}\cdot\mathcal{L}_{\text{dice}}^{(j,k)}+\lambda_{\text{focal}}\cdot\mathcal{L}_{\text{focal}}^{(j,k)}+\lambda_{\text{cls}}\cdot\mathcal{L}_{\text{cls}}^{(k)}.$ $$

For unmatched prototypes, we only compute $\mathcal{L}_{\text{cls}}^{(k)}$ with the ground truth label being “no-object”.

The final training loss includes auxiliary losses from each decoder layer $\ell=1,\dots,L$, as well as from the initial prototype vectors:

$$ $\mathcal{L}_{\text{total}}=\sum_{\ell=0}^{L}\mathcal{L}^{(\ell)}.$ $$

During inference, we assign each spacepoint $i$ to the track whose combined mask and classification score is maximal. Concretely, we compute
$k_{i}^{*}=\arg\max_{k}\bigl{(}\hat{p}_{ik}\,\hat{y}_{k}\bigr{)},$
and label point $i$ as belonging to track $k_{i}^{*}$.

This formulation enables end-to-end training of the instance segmentation model, while allowing the pretrained or learned point embeddings to guide track-level grouping.

#### Particle Identification and Noise Identification

For both PID and noise classification, we use a simple lightweight adapter:

- •
Embedding: A linear layer projects each point feature $\mathbf{x}_{i}\in\mathbb{R}^{d}$ to a $d_{p}$-dimensional embedding.
- •
Context: A single Self-attention layer aggregates global information across all point embeddings.
- •
Prediction: An MLP with softmax over $C$ output classes.

### Comparative Methods for Downstream Tasks

#### Adapt Exa.TrkX Pipeline for sPHENIX Tracking-Finding

In this section, we discuss the several adaptions to the Exa.TrkX pipeline for it to work well on the sPHENIX data. We need to apply adaptions to the first four stages – data pre-processing, hit embedding, edge filtering, and GNN edge classification – out of six stages of the Exa.TrkX pipeline.

Pre-processing. The Exa.TrkX’s study was based on the TrackML dataset (Amrouche et al. [2020](https://arxiv.org/html/2508.14087v1#biba.bib3)). The dataset provides two sources for the construction of the neural network input – the $3$ dimensional location of the spacepoints and the directional information and summary statistics from the charge deposited in each spacepoint ($8$-dimensional). The second source of information is called cell features by the paper. The hit feature is the concatenation of the location and cell features.
Since sPHENIX data does not provide cell features, we only used the location of hits in the HEP-coordinate to construct the input. More precisely, let $(\hat{\eta},\phi,\hat{r})$ be the location of a hit (normalized pseudorapidity, angle, and normalized radius), the features of this hit is a $5$-dimensional vector

$$ $\left(\mathcal{E},\hat{\eta},\cos(\phi),\sin(\phi),\hat{r}\right),$ $$

where $\mathcal{E}$ is the energy. We used $(\cos(\phi),\sin{\phi})$ instead of $\phi$ to overcome the discontinuity of $\phi$ at $2\pi$.
We normalized the pseudorapidity $\eta$ by $1.96$ to get the normalized pseudorapidity $\hat{\eta}\in(-1,1)$. To normalized a radius, we first match it to the closest one of the $48$ radius bins and use the bin index to replace the radius. And then, we divided the index by $48$ to normalized radius to a number between $[0,1)$. We do this because the distance between the sPHENIX TPC layers are not uniform with outer layers spacing farther apart than the inner ones. This may be a problem for distance-based edge set construction for a GNN model since same-track hits toward the end of the track may be less likely to be connected by the model.

Embedding and filtering. The Exa.TrkX pipeline embeds the spacepoints and filters the edges as two separate steps. To adapt them for sPHENIX, we modified the procedure in the following aspects: 1) how to determine whether a pair of hits is connected; 2) how candidate hit pairs are generated; 3) how to trained the models; and 4) how to construct the models.

In the embedding stage, Exa.TrkX trained a multi-layer perceptron (MLP) network to embed each hit into a latent representation so that pairs of neighboring hits from the same track are closer in the latent space than pairs that are not (e.g. from different tracks or not neighbors on the same track). The embedding network is trained by first passing the two hits through the same embedding network and then minimizing the hinge loss of the distance between the two embeddings.

Since sPHENIX data does not provide information to determine whether two same-track hits are direct neighbors (although this information could be inferred for high-energy tracks), we decided not to distinguish whether two same-track hits are neighboring or not. This approach was also recommended by the Exa.TrkX research as a valid alternative.

In the filtering stage, Exa.TrkX takes a pair of hits, passes them through the embedding network, concatenates the two embeddings, and pass the concatenation through a MLP filtering network to predict whether the two hits are connected. The prediction is optimized by a binary cross entropy loss.

For both the embedding and filtering models, we need to provide candidate hit pairs. For the embedding stage, Exa.TrkX uses two types of pairs: random pairs and k-nearest neighbor (KNN) pairs as a form of hard negative mining. As a random pair has an extremely low chance to be connected, Exa.TrkX also trains on pairs formed by a hit and its closest neighbors in the latent representation space.

We follow the pipeline as closely as possible. However, because of the different between sPHENIX and TrackML input features and the fact we treating all pairs from the same track as being connected (in contrast to Exa.TrkX’s approach where only immediate neighbors are connected), we had to choose different cutoffs in both embedding and filtering. More specifically, we set a threshold of $2.$ for distance in the embedding space with pairs less than the threshold apart classified as having an edge between them. The threshold was so chosen as it ensures that we have an over $.8$ recall (efficiency in the Exa.TrkX terminology) in identifying pairs from the same track. Note here we didn’t selected a threshold that will ensure close to a $100\%$ recall. This is because we can afford the model to fail to recognize faraway points from the same track as being connected.

For the filtering step, we chose a threshold of $.675$ for probability of a true edge with pairs over the threshold considered as being connected. The threshold was selected because it ensures the false positive rate in edge identification to go below $1\%$.

GNN edge classification.
For the final GNN step, we also used the Interaction Network (Battaglia et al. [2016](https://arxiv.org/html/2508.14087v1#biba.bib4)) architecture with the same hyperparameters used by the Exa.TrkX pipeline. For edge classification, we chose a threshold of $.9$ as probability of a true edge. With this choice, we achieved a $91.79\%$ tracking efficiency (recall) (and $94.74\%$ for tracks with $p_{\mathrm{T}}>$1\text{\,}\mathrm{GeV}$$), and a track purity (precision) of $66.42\%$. With a threshold of $.8$, the tracking efficiency drops slightly to $90.01\%$ (and $92.60\%$ for $p_{\mathrm{T}}>$1\text{\,}\mathrm{GeV}$$) with a large improvement in purity to $76.72\%$.

#### Adapt EggNet for sPHENIX Track-Finding

The EggNet study was also based on the TrackML dataset (Amrouche et al. [2020](https://arxiv.org/html/2508.14087v1#biba.bib3)) and share the same data pre-processing approach with Exa.TrkX. To partially compensate the lack cell features from sPHENIX data, we tried the following approach to augmented the input. Let $\left(\hat{\eta}_{0},\phi_{0},\hat{r}_{0}\right)$ be the location of a hit (normalized pseudorapidity, angle, and normalized radius), the features of this hit is a $12$-dimensional vector

$$ $\left(\hat{\eta}_{0},\cos(\phi_{0}),\sin(\phi_{0}),\hat{r}_{0};\,\hat{\eta}_{1},\cos(\phi_{1}),\sin(\phi_{1}),\hat{r}_{1};\,\hat{\eta}_{2},\cos(\phi_{2}),\sin(\phi_{2}),\hat{r}_{2}\right),$ $$

where $\left(\hat{\eta}_{1},\phi_{1},\hat{r}_{1}\right)$ and $\left(\hat{\eta}_{2},\phi_{2},\hat{r}_{2}\right)$ are the locations of the two closest neighbors of the hit in the $\left(\hat{\eta},\cos(\phi),\sin(\phi),\hat{r}\right)$ space. The motivation for augmenting the hit with two closest neighbors is that for the majority of the hits in a high energy track, the two closest neighbors are most likely from the same track in which case the augmented hit features can provide information on the direction of track.

For the GNN model, EggNet adopted a similar approach to GravNet (Qasim et al. [2019](https://arxiv.org/html/2508.14087v1#biba.bib39)). The outstanding feature of a GravNet-type model is that the edge set is not predetermined but constructed dynamically. More precisely, EggNet will run $N$ normal GNN iterations, but before each GNN iteration, the edge set will be constructed via KNN based on the current node embeddings. To adapt EggNet to sPHENIX data, we set GNN iterations to be $4$ and used $4$ message-passing rounds for each GNN iteration. The nearest $10$ hits in the embedding space are used to form the neighborhood of a hit. Different from the original GravNet (but similar to the interaction GNN used by Exa.TrkX), EggNet also has an edge network for calculating edge messages. Moreover, EggNet also used a dedicated node decoding network to produce the node embeddings for the KNN. All sub-networks of EggNet (node encoding/decoding networks and edge network) are MLPs with $2$ hidden layers and $64$ hidden feature each. The embedding dimension of the node (i.e. the number output features node decoding network) is $24$.

The network is trained with a hinge loss of margin $1$, aiming at reducing the Euclidean distance in the embedding space between a pair of hits from the same track and enlarge the distance between a pair from different tracks. The model was trained for $300$ epochs and the final clustering was done using DBSCAN with $\epsilon=1$ and minimum number samples $=2$.

#### Adapt GNNs for sPHENIX Particle Identification and Noise Tagging

We selected four GNN models: GATConv, GCNConv, GraphConv, and SAGEConv as benchmarking algorithms for the PID and noise-tagging downstream tasks.
We used the torch_geometric implementations for the models. We used the same data pre-processing protocol as discussed in [C](https://arxiv.org/html/2508.14087v1#A3.SSx2.SSSx1).
To generate the edge set, for a hit at location $\left(\eta,\cos(\phi),\sin(\phi),\hat{r}\right)$, we connect to it $50$ nearest neighbor hits with distance $<1$. We allowed the edges to be directed. The node features to the GNNs are the energy $\mathcal{E}$ of the hit together with its 4D location. For the node encoding network, we use a MLP with $2$ hidden layers and $256$ hidden features each. We use uniformly $6$ GNN layers for each GNN model. For the hit classification network, we use a MLP of $2$ hidden layers with $128$ and $64$ hidden features. The GNNs are trained with cross entropy loss. Each GNN is trained for $200$ epochs.

In general, GNNs’ performance on the two downstream tasks are suboptimal. We hypothesis that the failure of GNNs is a result of their difficulty in capturing and communicating more global patterns of the tracks as solving both particle identification and noise-tagging require a model to understand the general shape of tracks that span a significant space in TPC.

#### Adapt OneFormer3D for sPHENIX Particle Identification and Noise Tagging

OneFormer3D is a state-of-the-art object detection algorithm for 3D point cloud data that can solve semantic and instance segmentation task in one run. The model architecture of OneFormer3D is U-Net backbone followed by a Transformer decoder.

To run OneFormer3D on a point cloud data, we first need to get the so-called super points (a grouping of raw points) either by a clustering algorithm or voxelization. To adapt OneFormer3D to sPHENIX data, we used the same pre-processing approach as discussed in [C](https://arxiv.org/html/2508.14087v1#A3.SSx2.SSSx1) and voxelized the resulting point cloud to a grid of shape $(64,64,48)$ in $\hat{\eta},\phi,\hat{r}$, respectively.

The super points first pass through the sparse convolution-powered U-Net backbone to be featurized. Then the super point features serve as the keys and values in the Transformer encoder. The learnable queries output from the Transformer decoder are then used to produce instance/semantic segmentation predictions on the super points. In the final step, the prediction on the super points will be broadcast to their constituent raw points. Since both particle identification and noise-tagging can be considered as semantic segmentation tasks, we separated the part of the code (primarily in prediction and loss function) for semantic segmentation from OneFormer3D, while kept the neural architecture identical. We used the same network parameters as the example of OneFormer3D on the S3DIS dataset.

Figure: Figure 13: Performance of AdapterOnly and FM4NPP on Noise Tagging. The numbers in the parentheses in the target sub-figures are the number of signal and noise spacepoints. The numbers in the parentheses in the prediction sub-figures are the recall and precision of the class.
Refer to caption: x9.png

Figure: Figure 14: Performance of AdapterOnly and FM4NPP on particle identification. The numbers in the parentheses in the target sub-figures are the number of spacepoints in each particle ID class. The numbers in the parentheses in the prediction sub-figures are the recall and precision of the class.
Refer to caption: x10.png

Figure: Figure 15: Performance of AdapterOnly and FM4NPP on track finding. In panel (a), we show the ground-truth tracks, the AdapterOnly track candidates, and the FM4NPP track candidates (note that two different tracks might have the same color since the length of the color cycle we used may be smaller than the number of tracks). In panel (b)-(e), we show four pairs of close-by ground-truth tracks that the AdapterOnly model fails to separate while the FM4NPP model does.
Refer to caption: x11.png

**Table 3: Noise tagging per-class recall and precision.**
|  | Accuracy | Macro | Non‑noise | Noise |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- |
|  |  | Recall | Precision | Recall | Precision | Recall | Precision |
| GATConv | $0.9099$ | $0.6730$ | $0.8060$ | $0.9788$ | $0.9242$ | $0.3672$ | $0.6878$ |
| GCNConv | $0.9095$ | $0.6728$ | $0.8037$ | $0.9784$ | $0.9241$ | $0.3672$ | $0.6832$ |
| GraphConv | $0.9190$ | $0.7213$ | $0.8252$ | $0.9764$ | $0.9351$ | $0.4661$ | $0.7152$ |
| SAGEConv | $0.9174$ | $0.7227$ | $0.8165$ | $0.9740$ | $0.9355$ | $0.4714$ | $0.6975$ |
| OneFormer3D | $0.9646$ | $0.9404$ | $0.8948$ | $0.9716$ | $0.9884$ | $0.9092$ | $0.8012$ |
| AdapterOnly | $0.9111$ | $0.6215$ | $0.8359$ | $0.9901$ | $0.9169$ | $0.2528$ | $0.7548$ |
| FM4NPP(m6) | $0.9662$ | $0.9122$ | $0.9114$ | $0.9809$ | $0.9812$ | $0.8435$ | $0.8416$ |

**Table 4: Particle Identification per-class recall and precision.**
|  | Accuracy | Macro | Others | Pion | Kaon | Proton | Electron |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
|  |  | Rec. | Pre. | Rec. | Pre. | Rec. | Pre. | Rec. | Pre. | Rec. | Pre. | Rec. | Pre. |
| GATConv | $0.6922$ | $0.3973$ | $0.6368$ | $0.0947$ | $0.5709$ | $0.9106$ | $0.7014$ | $0.0057$ | $0.6146$ | $0.4567$ | $0.6117$ | $0.5190$ | $0.6854$ |
| GCNConv | $0.6892$ | $0.3911$ | $0.6319$ | $0.0782$ | $0.5762$ | $0.9140$ | $0.6966$ | $0.0073$ | $0.5871$ | $0.4501$ | $0.6140$ | $0.5058$ | $0.6858$ |
| GraphConv | $0.7079$ | $0.4176$ | $0.6425$ | $0.1304$ | $0.5739$ | $0.9133$ | $0.7146$ | $0.0080$ | $0.5791$ | $0.4766$ | $0.6272$ | $0.5597$ | $0.7178$ |
| SAGEConv | $0.7262$ | $0.4563$ | $0.6502$ | $0.1085$ | $0.5790$ | $0.9126$ | $0.7382$ | $0.0338$ | $0.5239$ | $0.6242$ | $0.7071$ | $0.6024$ | $0.7028$ |
| OneFormer3D | $0.7701$ | $0.4897$ | $0.5767$ | $0.3029$ | $0.5758$ | $0.9207$ | $0.7658$ | $0.0000$ | $0.0000$ | $0.4859$ | $0.6991$ | $0.7389$ | $0.8427$ |
| AdapterOnly | $0.6631$ | $0.3387$ | $0.6111$ | $0.0095$ | $0.7714$ | $0.9511$ | $0.6596$ | $0.0002$ | $0.2872$ | $0.4120$ | $0.6366$ | $0.3209$ | $0.7008$ |
| FM4NPP(m6) | $0.8547$ | $0.6623$ | $0.8328$ | $0.4449$ | $0.7647$ | $0.9551$ | $0.8484$ | $0.2712$ | $0.7829$ | $0.8068$ | $0.8763$ | $0.8336$ | $0.8919$ |

**Table 5: Diagnostic metrics for tracking performance.**
| model | ARI | overall spacepoint efficiency | overall spacepoint purity | no. parameters |
| --- | --- | --- | --- | --- |
| EggNet | $0.7256$ | $93.01\%$ | $92.34\%$ | $0.16$M |
| Exa.TrkX | $0.8765$ | $94.47\%$ | $98.83\%$ | $3.86$M |
| AdapterOnly | $0.7243$ | $89.34\%$ | $92.09\%$ | $2.39$M |
| FM4NPP(m6) | $0.9448$ | $97.56\%$ | $98.34\%$ | $188$M + $2.39$M |

### Additional Learned Embeddings Results

To investigate and interpret the effectiveness of learned latent representations from our pre-trained foundation model (FM), we conducted a comprehensive explainable AI (XAI) analysis. In Figure [16](https://arxiv.org/html/2508.14087v1#A3.F16), we present results obtained by applying various dimensionality reduction techniques (including PCA, t-SNE and UMAP) to both FM features and downstream adaptor features. For illustrative clarity, we randomly selected two test data samples. The results demonstrate consistent improvement, clearly showcasing the FM features’ adaptability: even after a single linear projection, the FM embeddings exhibit substantial clustering and separability, indicating rapid adaptation to the downstream track-finding task. Adaptor features consistently provided superior discrimination, yielding distinctly well-separated clusters corresponding to different track categories.

Figure: Figure 16: Dimensionality reduction results using PCA, t-SNE, and UMAP on randomly selected test data samples.
Refer to caption: x12.png

To further validate the robustness and generalizability of the FM features, we systematically investigated the impact of varying dimensionality reduction parameters using t-SNE. Specifically, we conducted experiments by setting the reduced dimensionality to 3, 4, and 5 and visualized the results by plotting the first two t-SNE components (See Figure [17](https://arxiv.org/html/2508.14087v1#A3.F17)). Across all tested dimensional configurations, the FM features consistently demonstrated pronounced clustering patterns and clear separability, highlighting their intrinsic adaptability and effectiveness in supporting diverse downstream classification tasks.

Figure: Figure 17: T-SNE visualizations for randomly selected test instances across various reduced dimensions.
Refer to caption: x13.png

In Figure [18](https://arxiv.org/html/2508.14087v1#A3.F18), we extended our analysis to multiple downstream tasks, again using randomly selected test data instances and employing t-SNE for visualization. The FM features’ separability was notably effective for the track-finding task, slightly diminished for particle identification, and considerably reduced for noise tagging. The limited performance observed in noise tagging is attributed to the inherent imbalance of the binary classification data, making separability challenging due to the dominant prevalence of a single label. Overall, our analyses confirm a hierarchy of effectiveness in FM embeddings across downstream tasks: track-finding demonstrates the strongest separability, followed by particle identification, and lastly noise tagging. These findings align well with the FM’s pretraining objective, neighbor identification, and are consistent with task relevance from a physics perspective.

Figure: Figure 18: T-SNE visualizations for randomly selected test instances across various downstream tasks.
Refer to caption: x14.png

## References

- Agostinelli et al. (2003)
Agostinelli, S.; et al. 2003.
GEANT4 - A Simulation Toolkit.
*Nucl. Instrum. Meth. A*, 506: 250–303.
- Aguilar et al. (2022)
Aguilar, M. R.; Chang, Z.; Elayavalli, R. K.; Fatemi, R.; He, Y.; Ji, Y.;
Kalinkin, D.; Kelsey, M.; Mooney, I.; and Verkest, V. 2022.
pythia8 underlying event tune for RHIC energies.
*Phys. Rev. D*, 105(1): 016011.
- Amrouche et al. (2020)
Amrouche, S.; Basara, L.; Calafiura, P.; Estrade, V.; Farrell, S.; Ferreira,
D. R.; Finnie, L.; Finnie, N.; Germain, C.; Gligorov, V. V.; Golling, T.;
Gorbunov, S.; Gray, H.; Guyon, I.; Hushchyn, M.; Innocente, V.; Kiehn, M.;
Moyse, E.; Puget, J.-F.; Reina, Y.; Rousseau, D.; Salzburger, A.;
Ustyuzhanin, A.; Vlimant, J.-R.; Wind, J. S.; Xylouris, T.; and Yilmaz, Y.
2020.
The Tracking Machine Learning Challenge: Accuracy Phase.
In Escalera, S.; and Herbrich, R., eds., *The NeurIPS ’18
Competition*, 231–264. Cham: Springer International Publishing.
- Battaglia et al. (2016)
Battaglia, P.; Pascanu, R.; Lai, M.; Jimenez Rezende, D.; et al. 2016.
Interaction networks for learning about objects, relations and
physics.
*Advances in neural information processing systems*, 29.
- Belmont et al. (2024)
Belmont, R.; et al. 2024.
Predictions for the sPHENIX physics program.
*Nucl. Phys. A*, 1043: 122821.
- Bodnar et al. (2025)
Bodnar, C.; Bruinsma, W. P.; Lucic, A.; Stanley, M.; Allen, A.; Brandstetter,
J.; Garvan, P.; Riechert, M.; Weyn, J. A.; Dong, H.; et al. 2025.
A foundation model for the Earth system.
*Nature*, 1–8.
- Bommasani et al. (2021)
Bommasani, R.; Hudson, D. A.; Adeli, E.; Altman, R.; Arora, S.; von Arx, S.;
Bernstein, M. S.; Bohg, J.; Bosselut, A.; Brunskill, E.; et al. 2021.
On the opportunities and risks of foundation models.
*arXiv preprint arXiv:2108.07258*.
- Brookhaven National Laboratory (2025)
Brookhaven National Laboratory. 2025.
sPHENIX Detector at RHIC.
https://www.bnl.gov/rhic/sphenix.php.
Accessed: 2025-07-19.
- Busza, Rajagopal, and van der Schee (2018)
Busza, W.; Rajagopal, K.; and van der Schee, W. 2018.
Heavy Ion Collisions: The Big Picture, and the Big Questions.
*Ann. Rev. Nucl. Part. Sci.*, 68: 339–376.
- Calafiura et al. (2024)
Calafiura, P.; Chan, J.; Delabrouille, L.; and Wang, B. 2024.
EggNet: An Evolving Graph-based Graph Attention Network for Particle
Track Reconstruction.
arXiv:2407.13925.
- Calafiura et al. (2018)
Calafiura, P.; Farrell, S.; Gray, H.; Vlimant, J.-R.; Innocente, V.;
Salzburger, A.; Amrouche, S.; Golling, T.; Kiehn, M.; Estrade, V.; Germaint,
C.; Guyon, I.; Moyse, E.; Rousseau, D.; Yilmaz, Y.; Gligorov, V. V.;
Hushchyn, M.; and Ustyuzhanin, A. 2018.
TrackML: A High Energy Physics Particle Tracking Challenge.
In *2018 IEEE 14th International Conference on e-Science
(e-Science)*, 344–344.
- Cheng et al. (2022)
Cheng, B.; Misra, I.; Schwing, A. G.; Kirillov, A.; and Girdhar, R. 2022.
Masked-attention Mask Transformer for Universal Image Segmentation.
arXiv:2112.01527.
- Cheng, Schwing, and Kirillov (2021)
Cheng, B.; Schwing, A. G.; and Kirillov, A. 2021.
Per-Pixel Classification is Not All You Need for Semantic
Segmentation.
arXiv:2107.06278.
- Collaboration, Aad et al. (2012)
Collaboration, A.; Aad, G.; et al. 2012.
Observation of a New Particle in the Search for the Standard Model
Higgs Boson with the ATLAS Detector at the LHC.
*Physics Letters B*, 716(1): 1–29.
- Dao and Gu (2024)
Dao, T.; and Gu, A. 2024.
Transformers are SSMs: Generalized Models and Efficient Algorithms
Through Structured State Space Duality.
In *Forty-first International Conference on Machine Learning*.
- Dosovitskiy et al. (2021)
Dosovitskiy, A.; Beyer, L.; Kolesnikov, A.; Weissenborn, D.; Zhai, X.;
Unterthiner, T.; Dehghani, M.; Minderer, M.; Heigold, G.; Gelly, S.;
Uszkoreit, J.; and Houlsby, N. 2021.
An Image is Worth 16x16 Words: Transformers for Image Recognition at
Scale.
In *International Conference on Learning Representations*.
- Fedus, Zoph, and Shazeer (2022)
Fedus, W.; Zoph, B.; and Shazeer, N. 2022.
Switch transformers: Scaling to trillion parameter models with simple
and efficient sparsity.
*Journal of Machine Learning Research*, 23(120): 1–39.
- Gu and Dao (2023)
Gu, A.; and Dao, T. 2023.
Mamba: Linear-time sequence modeling with selective state spaces.
*arXiv preprint arXiv:2312.00752*.
- Gu and Dao (2024)
Gu, A.; and Dao, T. 2024.
Mamba: Linear-Time Sequence Modeling with Selective State Spaces.
In *First Conference on Language Modeling*.
- Hoffmann et al. (2022)
Hoffmann, J.; Borgeaud, S.; Mensch, A.; Buchatskaya, E.; Cai, T.; Rutherford,
E.; Casas, D. d. L.; Hendricks, L. A.; Welbl, J.; Clark, A.; et al. 2022.
Training compute-optimal large language models.
*arXiv preprint arXiv:2203.15556*.
- Hubert and Arabie (1985)
Hubert, L.; and Arabie, P. 1985.
Comparing partitions.
*Journal of Classification*, 2(1): 193–218.
- Jiang and Qian (2025)
Jiang, C.; and Qian, S. 2025.
Application of Structured State Space Models to High energy physics
with locality sensitive hashing.
In *International Conference on Artificial Intelligence and
Statistics*, 3961–3969. PMLR.
- Ju et al. (2021)
Ju, X.; Murnane, D.; Calafiura, P.; Choma, N.; Conlon, S.; Farrell, S.; Xu, Y.;
Spiropulu, M.; Vlimant, J.-R.; Aurisano, A.; Hewes, J.; Cerati, G.; Gray, L.;
Klijnsma, T.; Kowalkowski, J.; Atkinson, M.; Neubauer, M.; DeZoort, G.;
Thais, S.; Chauhan, A.; Schuy, A.; Hsu, S.-C.; Ballow, A.; and Lazar, A.
2021.
Performance of a geometric deep learning pipeline for HL-LHC particle
tracking.
*The European Physical Journal C*, 81(10).
- Kalman (1960)
Kalman, R. E. 1960.
A New Approach to Linear Filtering and Prediction Problems.
*Journal of Basic Engineering*, 82(1): 35–45.
- Kaplan et al. (2020)
Kaplan, J.; McCandlish, S.; Henighan, T.; Brown, T. B.; Chess, B.; Child, R.;
Gray, S.; Radford, A.; Wu, J.; and Amodei, D. 2020.
Scaling laws for neural language models.
*arXiv preprint arXiv:2001.08361*.
- Klest (2020)
Klest, H. 2020.
Overview and design of the sPHENIX TPC.
*J. Phys. Conf. Ser.*, 1498: 012025.
- Kolodiazhnyi et al. (2024)
Kolodiazhnyi, M.; Vorontsova, A.; Konushin, A.; and Rukhovich, D. 2024.
Oneformer3d: One transformer for unified point cloud segmentation.
In *Proceedings of the IEEE/CVF Conference on Computer Vision
and Pattern Recognition*, 20943–20953.
- Li et al. (2024)
Li, Q.; Hu, Z.; Wang, Y.; Li, L.; Fan, Y.; King, I.; Song, L.; and Li, Y. 2024.
Progress and Opportunities of Foundation Models in Bioinformatics.
*Briefings in Bioinformatics*.
Survey of foundation models in bioinformatics.
- Loshchilov and Hutter (2017)
Loshchilov, I.; and Hutter, F. 2017.
Decoupled weight decay regularization.
*arXiv preprint arXiv:1711.05101*.
- Ma et al. (2024)
Ma, Q.; Jiang, Y.; Cheng, H.; and Xu, D. 2024.
Harnessing the deep learning power of foundation models in
single-cell omics.
*Nature Reviews Molecular Cell Biology*, 25(8): 593–594.
- Mildenhall et al. (2021)
Mildenhall, B.; Srinivasan, P. P.; Tancik, M.; Barron, J. T.; Ramamoorthi, R.;
and Ng, R. 2021.
Nerf: Representing scenes as neural radiance fields for view
synthesis.
*Communications of the ACM*, 65(1): 99–106.
- Moskowitz (2023)
Moskowitz, C. 2023.
Tiny Bubbles of Primordial Soup Re‑create Early Universe.
*Scientific American*, 328(3).
Accessed: 2025‑07‑19.
- Nguyen et al. (2023)
Nguyen, T.; Brandstetter, J.; Kapoor, A.; Gupta, J. K.; and Grover, A. 2023.
ClimaX: a25 foundation model for weather and climate.
In *Proceedings of the 40th International Conference on Machine
Learning*, ICML’23. JMLR.org.
- Novak et al. (2018)
Novak, R.; Bahri, Y.; Abolafia, D. A.; Pennington, J.; and Sohl-Dickstein, J.
2018.
Sensitivity and Generalization in Neural Networks: an Empirical
Study.
In *International Conference on Learning Representations*.
- Osborn et al. (2021)
Osborn, J. D.; Frawley, A. D.; Huang, J.; Lee, S.; Da Costa, H. P.; Peters, M.;
Pinkenburg, C.; Roland, C.; and Yu, H. 2021.
Implementation of ACTS into sPHENIX Track Reconstruction.
*Comput. Softw. Big Sci.*, 5(1): 23.
- Paganini (2018)
Paganini, M. 2018.
Machine Learning Algorithms for $b$-Jet Tagging at the ATLAS
Experiment.
*J. Phys. Conf. Ser.*, 1085(4): 042031.
- Pyzer-Knapp et al. (2025a)
Pyzer-Knapp, E. O.; Manica, M.; Staar, P.; Morin, L.; Ruch, P.; Laino, T.;
Smith, J. R.; and Curioni, A. 2025a.
Foundation models for materials discovery–current state and future
directions.
*Npj Computational Materials*, 11(1): 61.
- Pyzer-Knapp et al. (2025b)
Pyzer-Knapp, E. O.; Manica, M.; Staar, P.; Morin, L.; Ruch, P.; Laino, T.;
Smith, J. R.; and Curioni, A. 2025b.
Foundation models for materials discovery – current state and
future directions.
*npj Computational Materials*, 11: 15.
- Qasim et al. (2019)
Qasim, S. R.; Kieseler, J.; Iiyama, Y.; and Pierini, M. 2019.
Learning representations of irregular particle-detector geometry with
distance-weighted graph networks.
*The European Physical Journal C*, 79(7): 1–11.
- Rusch, Bronstein, and Mishra (2023)
Rusch, T. K.; Bronstein, M. M.; and Mishra, S. 2023.
A survey on oversmoothing in graph neural networks.
*arXiv preprint arXiv:2303.10993*.
- Sjöstrand et al. (2015)
Sjöstrand, T.; Ask, S.; Christiansen, J. R.; Corke, R.; Desai, N.; Ilten, P.;
Mrenna, S.; Prestel, S.; Rasmussen, C. O.; and Skands, P. Z. 2015.
An introduction to PYTHIA 8.2.
*Comput. Phys. Commun.*, 191: 159–177.
- sPHENIX Collaboration (2025a)
sPHENIX Collaboration. 2025a.
acts: A common tracking software toolkit for sPHENIX, tagged at
33fc284f238a24405bcd6c2de3260f370d6f8403.
https://github.com/sPHENIX-Collaboration/acts/tree/33fc284f238a24405bcd6c2de3260f370d6f8403.
Accessed August 3, 2025; part of the official sPHENIX build
environment.
- sPHENIX Collaboration (2025b)
sPHENIX Collaboration. 2025b.
calibrations: Calibration code for sPHENIX, tagged at
a3e66e69635514813ee3e20bf18b2bd59787b503.
https://github.com/sPHENIX-Collaboration/calibrations/tree/a3e66e69635514813ee3e20bf18b2bd59787b503.
Accessed August 3, 2025; part of the official sPHENIX build
environment.
- sPHENIX Collaboration (2025c)
sPHENIX Collaboration. 2025c.
coresoftware: Core simulation and reconstruction software for the
sPHENIX experiment, tagged at
b849eba5c2cf8ada510d036aa9b9499cb31f0513.
https://github.com/sPHENIX-Collaboration/coresoftware/tree/b849eba5c2cf8ada510d036aa9b9499cb31f0513.
Accessed August 3, 2025; used in the official sPHENIX build,
including downstream emulation and reconstruction.
- sPHENIX Collaboration (2025d)
sPHENIX Collaboration. 2025d.
macros: Analysis and utility macros for sPHENIX, tagged at
661f781db23352a3fa72055ce7dbf1a0ee1c2167.
https://github.com/sPHENIX-Collaboration/macros/tree/661f781db23352a3fa72055ce7dbf1a0ee1c2167.
Accessed August 3, 2025; part of the official sPHENIX build
environment.
- Stroud et al. (2024)
Stroud, S. V.; Duckett, P.; Hart, M.; Pond, N.; Rettie, S.; Facini, G.; and
Scanlon, T. 2024.
Transformers for Charged Particle Track Reconstruction in High Energy
Physics.
arXiv:2411.07149.
- Vankadara et al. (2024)
Vankadara, L. C.; Xu, J.; Haas, M.; and Cevher, V. 2024.
On feature learning in structured state space models.
In *The Thirty-eighth Annual Conference on Neural Information
Processing Systems*.
- Vaswani et al. (2017)
Vaswani, A.; Shazeer, N.; Parmar, N.; Uszkoreit, J.; Jones, L.; Gomez, A. N.;
Kaiser, Ł.; and Polosukhin, I. 2017.
Attention is all you need.
*Advances in neural information processing systems*, 30.
- Wang et al. (2023)
Wang, W.; Dai, J.; Chen, Z.; Huang, Z.; Li, Z.; Zhu, X.; Hu, X.; and et al.
2023.
InternImage: Exploring Large-Scale Vision Foundation Models With
Deformable Convolutions.
In *CVPR 2023*, 3591–3600.
- Yang et al. (2022)
Yang, G.; Hu, E. J.; Babuschkin, I.; Sidor, S.; Liu, X.; Farhi, D.; Ryder, N.;
Pachocki, J.; Chen, W.; and Gao, J. 2022.
Tensor programs v: Tuning large neural networks via zero-shot
hyperparameter transfer.
*arXiv preprint arXiv:2203.03466*.
- Zhou et al. (2023)
Zhou, Y.; Chia, M. A.; Wagner, S. K.; Ayhan, M. S.; Williamson, D. J.;
Struyven, R. R.; Liu, T.; Xu, M.; Lozano, M. G.; Woodward-Court, P.; et al.
2023.
A foundation model for generalizable disease detection from retinal
images.
*Nature*, 622(7981): 156–163.

## Peer Reviews

confidence: 4
contribution: 2
initial_rating: 4
presentation: 2
questions: - The model is positioned as a foundation for particle physics, yet it is trained only on RHIC data. Given that the LHC represents the forefront of particle physics, why was the model not trained or validated on LHC data to demonstrate its utility as a true foundation model for the entire field? The authors must justify this fundamental limitation in scope and discuss the model's generalizability to higher-energy, more complex LHC environments.
-  Can the authors quantify the computational overhead of the k-NNN objective compared to a baseline, and justify how the performance benefits warrant this increased expense?
soundness: 2
strengths: The authors present detailed technical considerations for building the foundation model, though there are shortcomings on specific design and experiment choices.
summary: The manuscript presents a foundation model for nuclear and particle physics, trained on proton-proton (p+p) collision data at a center-of-mass energy √s = 200 GeV. The proposed architecture utilizes the Mamba model as its backbone and is pretrained using a novel k-Next-Nearest-Neighbor prediction objective. The authors evaluate the model's performance on three downstream tasks: Track Finding, Particle Identification, and Noise Tagging.
weaknesses: - The manuscript does not adequately situate its contribution within the emerging landscape of foundation models for high-energy physics. It fails to discuss or compare against other recent efforts (e.g., models based on transformers, graph networks, or other architectures applied to similar data).
- The datasets used appear limited in scope, focusing on a specific collision system and energy. How does this restricted training data affect the model's validity and utility as a general-purpose foundation model for the broader field of nuclear and particle physics?

---

confidence: 3
contribution: 2
initial_rating: 4
presentation: 3
questions: - Were any evaluations run using the adapter models under a different (non-FM4NPP) spacepoint embedding model? This might be a distinct way to isolate the performance of the proposed FM architecture.
- As presented with the three downstream tasks, can this approach be trained end-to-end? The explicit adapter-based approach seems to be the most flexible route and keeps the backbone in more of an embedding role, but given the overlap in the three tasks it seems plausible that these could fully captured end-to-end (potentially internalizing/sharing knowledge across tasks previously isolated within the adapter models).
- Were any other kinds of downstream tasks tested (e.g., forecasting)?
soundness: 3
strengths: - The paper is well-organized, includes a comprehensive literature review, and provides high quality figures/diagrams.
- The paper's stated contributions are clear and address a difficult, high-impact problem in the NPP domain. The approach potentially lays the groundwork for tackling broader challenges relevant to scientific foundation models beyond particle physics settings.
- The reported evaluation is extensive, covering a variety of important dimensions that help position the model's utility and behavior. For instance, the model is compared to several baseline methods on the downstream tasks (highlighting its comparative advantages), key ablations are reported (justifying architectural decisions), and different model sizes are evaluated, highlighting scaling laws.
- I appreciate the discussion style of Section 5.3, which sets up several key questions relevant to practitioners seeking to leverage FM4NPP on new tasks.
summary: The paper introduces FM4NPP, a scientific foundation model for particle physics that attempts to address existing scaling challenges outside of natural language due to, e.g., the sparse nature of detector data, difficulties in serializing 3D data. The model is trained on simulated collisions under conditions of the sPHENIX experiment and evaluated on three core downstream tasks, mostly outperforming non-FM baselines on key metrics. FM4NPP is also shown to observe scaling laws at high parameter counts, and may present a useful paradigm for scientific FMs in other domains.
weaknesses: - I find the core positioning of the paper to be somewhat difficult to pin down. There is a clear focus on particle physics as the primary domain of interest, but the proposed training scheme for scaling and adapting FMs to downstream tasks is very general. To fully demonstrate the generality of the scheme, more (scientific) domains would need to be evaluated to verify the approach transfers well to other settings (helping substantiate the stated hypothesis that FMs encode task-agnostic representations useful for downstream tasks).

  Note that this isn't to take away from the model's performance on this task, but simply that the methodology leans more general-purpose while the evaluation focuses entirely on a single domain/dataset. 
- The downstream tasks used for evaluation appear limited in their variety. In particular, they seem to test for similar kinds of model understanding, which is to say classifying spatiotemporally connected groups of points in the particle space. For instance, given that the model performs well on track finding, it's not surprising that it would perform similarly well on particle identification or noise tagging (as these tasks, naively, simply re-group the tracks). Including downstream tasks like forecasting would be useful for demonstrating broader model understanding, more explicitly highlighting its ability to understand/extrapolate particle dynamics.
- It is ultimately quite difficult to asses how well the trained model fills the role of a foundation model. This point is made in tandem with the first two, i.e., that it's hard to gauge general model understanding provided the single dataset and task suite. What's concretely demonstrated is that FM4NPP is an effective embedding model for particles under conditions of the sPHENIX experiment, and large parameter counts can help with downstream classification tasks. But the jump to labeling FM4NPP as a foundation model is hard to justify without stronger evidence of its generality, such as more diverse tests of model understanding and/or evaluation under different conditions.

---

confidence: 3
contribution: 3
initial_rating: 6
presentation: 3
questions: * Why choose mamba over other linear transformers (deltanet, GLA..) and state space models? 
* How long are the sequence lengths for the input? State space models struggle with extremely long context. 
* Does the hierarchical raster scan have a strong impact on the amount of compute?
* What is the full model architecture of the foundation model?
* Can the code and models be made public?
* Do you actually claim that self-supervised pre-training + fine-tuning outperforms a dedicated model trained from scratch on the downstream task in Fig. 5 (b)? Or are the architectures different? If you extend the axis, would Adaptor only eventually converge to the FM performance, as is seen in other FM papers in particle physics?
soundness: 3
strengths: * The authors present a well motivated problem that they address with a multi-step comprehensive framework 
* The self-supervised learning objective is physics motivated, and intuitively works with the detector setup
* Very thorough benchmarking and ablation studies show improved performance for all pieces of the foundation model
* Performance on downstream task show greatly increased performance over baselines
* Scaling curves show increased performance for increased flops/parameter count, indicating scalability of the model
* Shows greatly increased performance against state of the art models
* Shows that the self-supervised learning technique improves performance on downstream tasks
summary: This work introduces a foundation model tailored towards nuclear and particle physics. The authors develop a large scale open dataset with 10 million events and benchmark on three downstream tasks. The authors develop a self-supervised training methodology for their foundation models, and present benchmarks on downstream tasks in addition to scaling behaviors for their foundation models. They demonstrate improved performance of their model over baselines across all tasks.
weaknesses: * Does not justify choice of mamba over linear transformer models, or other state space model alternatives
* Unclear how the hierarchical raster scan would impact the efficiency
* No benchmarks against efficient transformer baselines such as HEP-T (locality sensitive hashing transformer for high energy physics applications, https://arxiv.org/abs/2402.12535), which performs very well on trackML datasets
* For PID, also missing comparisons to dedicated physics ML algorithms, like MLPF (https://arxiv.org/abs/2503.00131) or HGPF (https://arxiv.org/abs/2410.23236)
* Does not define the model architecture/construction (number of layers, parameters per layer etc)
* There are no code or pretrained weights available
* Unclear of pretraining + fine-tuning outperforms dedicated models trained from scratch; Most other literature on FMs in particle physics do not claim this and instead focus on data efficiency (i.e. better performance when training on smaller datasets)

---

confidence: 4
contribution: 3
initial_rating: 6
presentation: 4
questions: 1. Have you evaluated FM4NPP embeddings on real sPHENIX runs (even small samples)? How does sim-trained FM perform zero-shot/adapter-shot on real data, and what domain-gap mitigation (calibration, augmentation, feature normalization) is most effective?
2. How do different grid resolutions $r \times \eta \times \phi$, binning strategies, or non-radial intra-box sortings affect pretraining loss and downstream ARI? Could a learnable/local ordering, or permutation-invariant SSM input layer, match or exceed Hierarchical Raster?
3. Why constrain neighbors strictly to $r_j > r_i$ rather than a cone or helix-aware neighborhood? Did you try multi-horizon targets mixing local and mid-range neighbors, or contrastive variants that avoid explicit regression?
4. For tracking, why a DETR-style query decoder over bipartite clustering in embedding space? For PID/noise, did you test slightly larger heads or lightweight decoders (e.g., 2–4 self-attention layers) to probe head-capacity vs. FM-quality trade-offs?
soundness: 3
strengths: 1. The paper targets an important gap: general, reusable representations for sparse detector data rather than bespoke task models. The two-stage “pretrain FM -> freeze ->  task adapters” design is well-motivated.
2. The Hierarchical Raster Scan balances global outward geometry with local track continuity; k-NNN aligns the self-supervised target with physics causality (increasing radius) rather than sequence order. The ablation table isolates benefits over next-token prediction and Hilbert curves.
3. Clear power-law trends for model/data/compute; the paper also documents hardware/iterations, optimizer, and $\mu$-param transfer, useful for reproducibility. Also, FM4NPP + small adapters beats GNN and 3D point-cloud baselines on ARI and efficiency.
summary: The paper proposes FM4NPP, a self-supervised foundation model for nuclear & particle physics (NPP) built on a Mamba (SSM) backbone. It introduces (i) a >10M-event simulated RHIC/sPHENIX TPC dataset and three downstream tasks (track finding, particle ID, noise tagging), (ii) a Hierarchical Raster Scan to serialize sparse detector spacepoints, and (iii) a k-Next-Nearest-Neighbor (k-NNN) autoregressive pretraining objective that predicts outward (in radius) neighbors to avoid order-leakage. With frozen FM features and lightweight adapters, the largest model (188M params) reportedly outperforms GNN/point-cloud baselines across tasks and shows clean scaling trends w.r.t. model/data/compute.
weaknesses: 1. The approach based on the proposed ordering. Although ablations compare Hierarchical Raster vs. Hilbert, it’s unclear how sensitive performance is to bin sizes, box aspect ratios, or detector layout changes (e.g., silicon layers, calorimeters), and whether learned positional encodings could reduce this hand-crafted dependency.
2. k-NNN chooses neighbors with a larger radius (future in $r$). That choice encodes a physics prior (outward propagation) but may under-represent curling/looping tracks, secondaries, or back-scattering. Ablations vary $k$ but not the neighborhood definition (e.g., cone in $\eta,\phi, r$).
3. All tasks are TPC-centric, point-level segmentations. For a foundation model, it would be compelling to include fusion tasks (TPC+EMCal), rare-event tagging, vertexing, or particle-flow style reconstruction, even as small-scale probes.


Decision: Accept (Poster)