betaFeedback

WorksPhysics and Astronomy

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

Abstract

Modern scientific instruments operate under increasingly extreme constraints on bandwidth, latency, and power. Inference at the sensor edge determines experimental data collection efficiency by deciding which information to save for further analysis. Particle tracking detectors at the Large Hadron Collider exemplify this challenge: pixelated silicon sensors generate rich spatiotemporal ionization patterns, yet most of this information is discarded due to data-rate limitations. Concurrently, advancements in co-design tools provide rapid turn-around for incorporating machine learning into application-specific integrated circuits, motivating designs for particle detectors with new integrated technologies. We demonstrate that neural networks embedded in the front-end electronics can infer charged-particle kinematic parameters from a single silicon layer. We regress hit positions and incident angles with calibrated uncertainties, while satisfying stringent constraints on numerical precision, latency, and silicon area. Our results establish a path toward probabilistic inference directly at the edge, opening new opportunities for intelligent sensing in high-rate scientific instruments.

Introduction

Modern high-energy physics (HEP) experiments study the fundamental building blocks of matter by analyzing high-rate data that requires real-time inference under strict latency and bandwidth constraints. The multipurpose ATLAS [1] and CMS [2] experiments at CERN’s

Large Hadron Collider (LHC) generate petabytes of data per second, but the majority is discarded by real-time filtering systems, known as triggers, which consist of both specialized processing hardware and commodity computing. The unique latency, radiation, power, and data rate constraints define a machine learning (ML) regime fundamentally different from conventional edge or embedded inference. Our proposed methods reduce an array of on-sensor charge information to a fixed-length set of kinematic variables, thereby achieving rate reduction not possible with traditional methods.

Like most accelerator-based HEP experiments, ATLAS and CMS employ silicon tracking detectors, or trackers, in the region closest to the proton-proton (pp) collision point. Trackers provide precise measurements of each outgoing charged particle by sampling points along its trajectory (track), which can be used to reconstruct its point of origin (vertex). Track and vertex information constitute critical input to flagship measurements targeted at the LHC and high-luminosity LHC (HL-LHC) [3, 4] programs.

The high particle density in the trackers combined with the number of detector channels – O(100 million)O(100\ \text{million}), to be upgraded to O(2 billion)O(2\ \text{billion}) for the HL-LHC – results in a data rate that far exceeds the bandwidth available for transfer and analysis at the pp collision frequency of 40 MHz. The trigger must therefore rely on other detector subsystems to determine which collisions to save for further processing. While future trigger systems will incorporate limited tracking information [5], data from the pixel detector, the central and most finely segmented portion of the tracker, remain inaccessible to real-time inference due to bandwidth constraints. The increased granularity of next-generation pixel detectors will exacerbate this problem by further increasing the overall volume of data produced by the detector.

In this work, we demonstrate the feasibility of on-detector reduction of pixel data using ML algorithms embedded directly in the front-end readout chip, or ASIC. A mixture density network [6] is trained on the ionization signature of a charged particle in a single pixel layer to regress properties that are directly relevant for track and vertex reconstruction, such as particle hit position and incident angle. Variations on this model explore the impact of different architectures and number of outputs on both physics and hardware performance. All models must satisfy strict area, latency, and power constraints. Model performance is studied as such constraints are introduced, and candidate algorithms are synthesized for the 28 nm CMOS process using high level synthesis (HLS) [7]. The performance of the regression models exceeds that of traditional reconstruction methods.

The proposed regression models reduce an array of on-sensor charge information to a fixed-length set of kinematic variables, thereby decoupling the volume of output data and the geometry of the pixel sensor. This approach will enable future experiments to capitalize on the increased precision afforded by smaller pixels with little cost to the total bandwidth. This would unlock pixel detectors for use in high-rate real-time trigger and processing systems, which has not yet been achieved in HEP experiments.

Related Work

On-detector data reduction is a central requirement for high-rate tracking detectors at the LHC. The CMS Phase-2 Outer Tracker addresses this challenge by locally correlating hits in closely spaced sensor modules to form track stubs consistent with charged particles whose transverse momentum exceeds a programmable threshold, thereby reducing the data volume transmitted to the Level-1 trigger system [5, 8]. In parallel, modern pixel readout ASICs, such as those developed by the RD53 collaboration, provide highly optimized front-end amplification, digitization, buffering, zero suppression, and high-speed readout under the radiation and bandwidth constraints of the HL-LHC environment [9]. These systems establish the feasibility and necessity of local processing in detector front-end electronics, but they do not exploit the full charge pattern within a pixel cluster to infer local track parameters at the sensor edge.

Earlier work on intelligent tracking detectors explored moving data reduction and pattern recognition closer to the sensor through advanced integration technologies. Vertically integrated pixel readout devices demonstrated that multiple tiers of electronics could be combined with fine-grained pixel arrays to form compact, highly integrated detector modules [10]. Related studies of three-dimensional integrated tracker modules proposed local correlations between closely spaced sensor layers to provide momentum discrimination before off-detector transmission [11]. These developments established the broader intelligent-tracker concept: using integration and local logic to reduce data at the point where it is produced. We build on this foundation by replacing deterministic local reductions with learned inference that maps the full pixel-cluster charge pattern to continuous track-parameter estimates and their uncertainties.

More recent smartpixels studies have applied ML to reduce pixel-detector data at the sensor edge. There, neural network classifiers are trained on pixel-cluster charge patterns to reject hits from low-momentum particles before readout, and the associated readout architecture integrates charge-sensitive amplification, in-pixel digitization, and embedded digital neural network logic in 28 nm CMOS [12, 13]. Alternative approaches based on neuromorphic computing have also been explored for compact on-sensor transverse-momentum filtering [14]. These works establish ML as a viable mechanism for on-detector filtering. This work extends that direction from binary or threshold-based filtering to calibrated regression of local track parameters and their uncertainties.

The charge distribution of a pixel cluster has also been studied in the context of limited-precision readout. Prior work showed that a small number of digitized charge bits can preserve much of the information needed for hit efficiency, position resolution, cluster classification, and particle identification in HL-LHC pixel detectors [15]. Charge sharing is likewise central to traditional local hit reconstruction in the CMS pixel detector, where projected cluster shapes and boundary-pixel charges are used to estimate the position of a hit [16]. These studies motivate low-precision charge measurements for local reconstruction, but they rely on fixed reconstruction rules or offline information, whereas we learn a task-specific mapping from the full pixel-cluster charge pattern to local track parameters, constrained by the front-end ASIC.

Together, these studies show that local processing is essential for future high-rate tracking detectors, and that increasingly sophisticated logic can be integrated into pixel readout ASICs. Existing approaches reduce data primarily by exploiting local correlations, applying fixed reconstruction rules, or making binary filtering decisions. We instead use the pixel-cluster charge pattern to regress continuous charged-particle parameters directly at the sensor edge. The probabilistic formulation additionally provides a calibrated uncertainty for each prediction, so that the reduced on-detector representation preserves information relevant for downstream track and vertex reconstruction.

Simulated Dataset

The spatial distribution and time evolution of charge deposited in a pixel array are sensitive to the traversing particle’s kinematic properties. A particle’s trajectory at the mid-plane of the pixel sensor is described by the following variables in the coordinate system of the sensor, shown in Figure 1: the hit position xx, yy where the particle traverses the sensor; the polar incident angle α\alpha; and the azimuthal incident angle β\beta.

Figure 1. The silicon sensor is described by a Cartesian coordinate system in which the xx-axis is parallel to the LHC beam direction, the yy-axis lies in the sensor plane and is orthogonal to xx, and the zz-axis is normal to the sensor plane, pointing outward from the interaction region through the depleted sensor volume. The incident angles α\alpha and β\beta are defined with respect to this coordinate system.

The ML models described in this work are trained on simulated datasets of charged pion interactions in an array of pixels implemented in high resistivity silicon [17]. Electric field maps are generated using Silvaco TCAD [18] for a futuristic sensor geometry. The simulated sensor is composed of an array of 16×1616 \times16 pixels, oriented in the xyxy plane, with pitch 50 μ\mum in xx and 12.5 μ\mum in yy. The thickness of the simulated sensor is 100 μ\mum, and its volume is depleted of charge carriers by a reverse bias of -100 V. The sensor is immersed in a 3.8 T magnetic field oriented parallel to the xx-axis.

Charged pions are generated at a distance of 30 mm from the silicon sensor. Positively and negatively charged pions are generated in equal numbers. The interaction of the charged pions with the sensor and subsequent charge collection and signal induction are simulated using PixelAV [19] using the electric field maps described above. Charge is collected as a cumulative sum in each pixel over a time window of 4 ns in 200 ps increments.

Only charge clusters that are fully contained in the simulated pixel array are considered: clusters with a total charge of 50 electrons or more deposited in the boundary pixels of the 16×1616 \times16 pixel matrix are discarded. The analysis of clusters extending beyond the boundary of this array is left to future work.

Two angular ranges are simulated. The first, used for training, places no constraints on how far in xx and yy a sensor module can extend. The resulting large ranges for both α\alpha and β\beta are limited only by the criterion that all clusters be contained in a 16×1616 \times16 array. This first dataset of 520,000 clusters is partitioned into 80% and 20% for training and validation respectively. The second angular range assumes a sensor width (in yy) of 16 mm, which restricts β\beta to a more realistic range. This dataset is used to evaluate the performance of the neural network models.

Regression Models

To evaluate the feasibility of multiple implementation options, a suite of neural network algorithms is trained to predict charged particle xx, yy, cot⁡α\cot\alpha, and cot⁡β\cot\beta. For each model, three variants are trained to study how on-chip resource utilization depends on the details of the readout:

  1. The Max model predicts values for xx, yy, cot⁡α\cot\alpha, cot⁡β\cot\beta, and the covariance matrix, for a total of 14 outputs.

  1. The Full models predict values for xx, yy, cot⁡α\cot\alpha, cot⁡β\cot\beta, and the uncertainty of one standard deviation on each variable (σv\sigma_v for v∈{x,y,cot⁡α,cot⁡β}v \in\{x,y,\cot\alpha,\cot\beta\}), for a total of 8 outputs.

  1. The Slim models predict values for xx, yy, and cot⁡β\cot\beta only, for a total of three outputs.

The Max model provides the most information about the incident particle track, and the Full models provide nearly the same information since the off-diagonal elements of the covariance matrix are close to zero. The Slim models focus on a limited set of parameters selected for their potential to benefit a hardware-based track trigger. Because they output the least data, the Slim models are most likely to meet LHC bandwidth constraints. Because the Max and Full models allow for detailed error analysis, they provide critical validation of Slim model predictions.

All models are implemented in TensorFlow [20] using the Keras API [21]. Neural network training is performed on batches of 5000 clusters each for 1000 epochs with no early stopping. For each run, we retain the model weights corresponding to the best validation performance observed across the entire training history. All models are trained using the Adam optimizer [22] with Nesterov Momentum incorporated [23] and a learning rate of 10−310^{-3}.

For the Max and Full models, we employ a mixture density network (MDN) [6] to describe the possible parent distributions of reconstructed tracks. The response and resolution distributions of reconstructed tracks are inherently multi-Gaussian, but safely approximated as Gaussian per-cluster, from the varying number of hits per cluster. Therefore, the network predicts the parameters of a single multi-dimensional Gaussian, and we construct a loss function from the mixture of the MDN at the level of the likelihood over the training data. The predicted means and standard deviations of the multidimensional Gaussian correspond to the regressed track parameters and uncertainties. We compare these uncertainties to residuals and confirm that our model is learning well-calibrated predictions. For the Slim models, which predict parameters without uncertainties, a mean-squared-error (MSE) loss function is used.

Three model architectures are tested: one is based on 2D convolutional layers (Conv2D), the second is based on 1D convolutional layers (Conv1D), and the third is a multi-layer perceptron (MLP).

Conv2D architecture

The Conv2D models take as input two-dimensional arrays of collected charge. As shown in Figure 2a, the network begins with two convolutional stages that extract spatial features from the 2D charge image, then applies average pooling to reduce the spatial resolution and parameter count, and finally uses three dense layers to generate the regression outputs.

Diagram of the architecture and bit precision for each layer of the Conv2D, Conv1D, and MLP models

Figure 2. Diagram of the architecture and bit precision for each layer of (a) the Conv2D, (b) the Conv1D, and (c) the MLP models.

The convolutional front-end of the model begins with a two-dimensional depthwise-separable convolution (SeparableConv2D), implemented as a depthwise spatial convolution followed by a 1×11 \times1 pointwise convolution. This decomposition substantially reduces the number of parameters and multiply-accumulate operations compared to a standard Conv2D layer, while maintaining sensitivity to local spatial structure in the charge footprint [24, 25]. In our implementation, the depthwise stage uses a 3×33 \times3 kernel and the pointwise stage projects the result into 5 output feature maps. The separable convolution is followed by a hyperbolic tangent activation (tanh). A second convolutional stage then applies a standard Conv2D layer with 5 filters and a 1×11 \times1 kernel, followed by another tanh activation. Finally, an average pooling layer (AvgPool) reduces the spatial resolution of the feature maps, limiting the size of the subsequent dense layers and reducing the complexity of a hardware implementation.

After the pooling stage, the feature maps are flattened and passed to a three-layer fully connected stage. The first two dense layers contain 16 nodes each and are followed by tanh activations. The third and final dense layer produces the regression output, with 14, 8 or 3 nodes for the Max, Full, and Slim Conv2D configurations, respectively.

Finally, to mitigate overfitting and stabilize the learned response to fluctuations in the collected charge patterns, we apply L1L2(0.01) regularization to the layer weights and constrain intermediate activations using an L2(0.01) activity penalty.

Conv1D architecture

The Conv1D models take as input two-dimensional arrays of collected charge and build one-dimensional summaries by constructing the xx- and yy-projections through a pair of initial average pooling branches. Because these projections collapse one dimension, they discard spatial information in the charge footprint. As a result, this architecture is not suitable for the Max configuration, which additionally regresses the full covariance matrix and therefore requires modeling correlations between xx, yy, cot⁡α\cot\alpha, and cot⁡β\cot\beta in a consistent way. Each projection is then processed by its own 1D convolutional layer, and the resulting feature sequences are concatenated and passed to a three-layer fully connected block to produce the regression outputs. A diagram of the Conv1D architecture is shown in Figure 2b.

Concretely, the xx-projection is obtained via AveragePooling2D with pooling window (1,16)(1,16), averaging along the yy direction while preserving the xx coordinate. The yy-projection is obtained with pooling window (16,1)(16,1), averaging along the xx direction while preserving yy. After pooling, each projection is reshaped into a sequence of length 16, retaining the time-slice dimension as channels. Each branch is then processed by a Conv1D layer with 5 filters and kernel size 3. The two branches are concatenated along the sequence dimension and passed through a tanh activation. The output is flattened and passed to two dense layers with 16 nodes and tanh activations, followed by a final dense layer with 8 or 3 outputs for the Full and Slim configurations, respectively.

MLP architecture

The MLP models take as input two-dimensional arrays of collected charge and replace the convolutional front-end with a lightweight projection stage followed by the same fully connected regression block described in Sec. IVB. Specifically, the input is summarized into an xx-projection and a yy-projection using two AveragePooling2D branches; each projection is flattened and passed through a dense layer that maps it into a compact latent representation. We use a ReLU activation in these projection branches to avoid early saturation effects that can occur with bounded nonlinearities (e.g., tanh). The two latent vectors are concatenated and processed by an additional dense layer with hidden=16hidden = 16 units and a tanh nonlinearity, which forms the final embedding.

The embedding is then passed to a fully connected three-layer regression stage consisting of two dense hidden layers with 16 nodes each and tanh activations, followed by a linear output layer. The output dimension is set to 8 for the Full configuration and to 3 for the Slim configuration. As in the previous architectures, we apply the L1L2(0.01) regularization to the layer weights and an L2(0.01) activity penalty to intermediate activations to improve generalization and stabilize the learned response to fluctuations in the charge patterns.

Input Charge Digitization with End-to-End Training

The analog front-end in the proposed ASIC uses a charge-sensitive amplifier (CSA) [26] followed by a flash analog-to-digital converter (ADC) to convert the charge collected in each pixel to a two-bit discrete representation. This discretization, referred to as digitization, is emulated in model training by partitioning the full range of charge into four bins. The collected charge per pixel in the simulated dataset is digitized by assigning each pixel the corresponding bin index:

D(Qin)={0if −∞<Qin<T01if T0≤Qin<T12if T1≤Qin<T23if T2≤Qin<+∞(1)D(Q_{\mathrm{in}}) = \begin{cases} 0 & \text{if } -\infty< Q_{\mathrm{in}} < T_0 \\ 1 & \text{if } T_0 \le Q_{\mathrm{in}} < T_1 \\ 2 & \text{if } T_1 \le Q_{\mathrm{in}} < T_2 \\ 3 & \text{if } T_2 \le Q_{\mathrm{in}} < +\infty \end{cases} \tag*{(1)}

where thresholds T={−∞,T0,T1,T2,∞}\mathcal{T} = \{-\infty, T_0, T_1, T_2, \infty\} correspond to the boundaries of the selected charge bins. The threshold values can be configured on-chip by adjusting bias voltages.

The choice of thresholds determines what information about the charge cluster is passed to the regression network, which is implemented in digital logic downstream of the ADC. We perform end-to-end training in which the optimal thresholds are learned jointly with the inference task. A dedicated neural network is used to extract the optimal thresholds by relating them to trainable parameters in a custom SoftQuantize layer. This layer is prepended to the nominal regression models and performs the function of digitization by the ADC in training. The sole purpose of this layer is to learn the optimal thresholds (T\mathcal{T}), and it is not intended for implementation on-ASIC. This approach allows the network to discover a digitization scheme that preserves task-relevant information. Conceptually, this shifts digitization from a fixed engineering choice to a learned component of the inference pipeline.

Formulation of SoftQuantize

Physically meaningful thresholds must be strictly ordered, i.e. Tj−1<TjT_{j-1}<T_j for all jj. Instead of defining T\mathcal{T} directly, we therefore define a set of unconstrained trainable parameters θ\theta, which are transformed into strictly positive intervals Δ\Delta:

Δi=ln⁡(1+eθi),(2)\Delta_i = \ln(1+e^{\theta_i}), \tag*{(2)}

The physical thresholds are then constructed as the cumulative sum of these positive intervals, starting from a lower bound Tmin⁡T_{\min}, as

Tj:=Tmin⁡+∑k=0jΔk.(3)T_j := T_{\min}+\sum_{k=0}^{j}\Delta_k. \tag*{(3)}

This transformation guarantees monotonicity in T\mathcal{T} and Tj>Tmin⁡T_j>T_{\min} for any real-valued θ\theta.

Standard “hard” quantization functions, such as (1), employ non-differentiable step functions that block any gradient flow required during backpropagation. To optimize the thresholds and model weights via gradient-descent, we instead introduce a differentiable SoftQuantize layer to perform the function of the ADC during training.

The SoftQuantize layer employs a Straight-Through Estimator (STE)-like strategy using hard quantization DD (Equation 1) during the forward pass and a differentiable formulation, DsoftD_{\mathrm{soft}}, for gradient approximation during the backward pass. We define the “soft” quantization using the logistic sigmoid function σ\sigma:

Dsoft(x):=∑j=02B−1σ(k⋅(Tj−x)τj).(4)D_{\mathrm{soft}}(x):=\sum_{j=0}^{2^B-1}\sigma\left(\frac{k\cdot(T_j-x)}{\tau_j}\right). \tag*{(4)}

Two key parameters control the behavior of the soft quantization: the local scale factor τj\tau_j and dimensionless global temperature kk.

The local scale factor is used to make the sigmoid functions insensitive to the relative bin width. For each threshold, τj\tau_j is defined as

τj:=Δj+Δj+12.(5)\tau_j:=\frac{\Delta_j+\Delta_{j+1}}{2}. \tag*{(5)}

Importantly, scaling by τj\tau_j also makes the temperature kk dimensionless and global across the sigmoids, allowing a single variable to control the overall steepness. Larger values of kk produce steeper sigmoids, and in the limit of infinite temperature, the sigmoids converge to step-functions. To leverage this behavior during optimization, the temperature kk is annealed over the course of training. The temperature is initiated with a small value kinit≃1k_{\mathrm{init}}\simeq1 and slowly increased to a larger value kmax⁡≃67k_{\max}\simeq67 as the training progresses. A cosine annealing schedule is used to control the annealing.

Selection of thresholds

The choice of thresholds in a pixel detector is driven by the amount of intrinsic sensor and electronic noise, with the lowest threshold typically corresponding to an upward fluctuation of five standard deviations (σ\sigma). In the input data for the threshold optimization training, an additional charge ϵ\epsilon is injected to reflect detector noise. The total charge collected in each pixel becomes

Qin=Qsim+ϵ,(6)Q_{\mathrm{in}}=Q_{\mathrm{sim}}+\epsilon, \tag*{(6)}

where QsimQ_{\mathrm{sim}} is the simulated charge resulting from a traversing particle and ϵ\epsilon is randomly sampled from a Gaussian distribution N(0,σnoise)\mathcal{N}(0,\sigma_{\mathrm{noise}}). The value of σnoise\sigma_{\mathrm{noise}} is estimated to be 80 electrons based on simulations designed in the Cadence Virtuoso flow and simulated with Spectre [27].

The optimal thresholds are determined by training the Max model with a SoftQuantize layer on the noisy input data. A high-capacity transformer architecture [28, 29] is chosen for this task to ensure robust convergence of the charge thresholds. The transformer was trained multiple times with random initial thresholds, as shown in the upper panel of Figure 3. The model converges to approximately the same set of thresholds regardless of initial values. The mean and standard deviation of the learned thresholds are displayed in Figure 3.

Figure 3. Top: Threshold values as a function of epoch in the training of the Max transformer with SoftQuantize. Bottom: Points indicate the preferred charge thresholds for each regression model. The vertical lines and shaded bands represent, respectively, the means and standard deviations of the thresholds obtained by the transformer.

The mean thresholds determined by the transformer were subsequently used as the initial values for trainings of the resource-constrained models with the SoftQuantize layer on the noisy input data. The preferred thresholds for each model, shown in the lower panel of Figure 3, are overall close to those determined by the transformer. The optimal minimum threshold for all models is higher than that selected by the transformer, but below the 5σ5\sigma level at which most pixel detectors operate.

Results

We demonstrate for the first time that ML methods can regress particle hit positions and incident angles from ionization patterns in a single tracking detector layer. We also present comprehensive studies of model variants that explore the trade-off between information content, uncertainty quantification, and hardware feasibility when inference is pushed to the sensor edge.

Each model presented is trained in four configurations corresponding to different levels of realism in hardware implementation and data preparation. These configurations, ordered from most idealized to most realistic, are:

  1. Training data consisting of simulated charge collected at 2020 time frames separated by 200200 ps, each with electron-level precision; network weights and activations have 32-bit floating-point precision. These models serve as an indicator of optimal performance.

  1. Training data consisting of simulated charge collected at two time frames separated by 3.8 ns, each with electron-level precision; network weights and activations have 32-bit floating-point precision.

with electron-level precision; network weights and activations have 32-bit floating-point precision.

  1. Training data consisting of simulated charge collected at two time frames separated by 3.8 ns, each with two-bit precision and using the optimal thresholds shown in the lower panel of Figure 3; network weights and activations have 32-bit floating-point precision.

  1. Training data consisting of simulated charge collected at two time frames separated by 3.8 ns, each with two-bit precision; convolutional weights and biases are quantized using fixed<4,1>, while dense-layer weights and biases use fixed<8,1>. Activation and intermediate precisions are selected separately through profiling. This is the model variant synthesized in § 8, where the precision choices are described in detail.

A summary of the residuals Rv=v−vtrueR_v = v - v_{\mathrm{true}} for v∈{x,y,α,β}v \in\{x, y, \alpha, \beta\} is shown in Figure 4 for all models. The points represent the mean of the residual distribution (Rˉv\bar{R}_v), and the solid lines represent the minimum interval containing 68% of clusters in the test set, Iv(68%)I_v(68\%). The Conv2D models have the widest residual distributions, and therefore the poorest resolution, for most parameters, while the Conv1D and MLP models achieve similar performance. The residual distributions have little dependence on the number of outputs.

Comparison of residuals for x, y, α, and β across all models

Figure 4. Comparison of the residuals for xx, yy, α\alpha, and β\beta for all models. The solid lines represent the minimum interval containing 68% of clusters. For the Max and Full models, the shaded bands represent the mean predicted uncertainty on each variable. Across architectures, the dominant performance degradation arises from temporal sparsification of the input, whereas aggressive charge quantization introduces comparatively minor loss.

For the Max and Full models, where an uncertainty σv\sigma_v is predicted for each variable vv, the mean regressed uncertainty is represented by the shaded bands in Figure 4. For xx, yy, and β\beta, the predicted σv\sigma_v is close to but greater than Iv(68%)I_v(68\%), indicating that the model slightly over-estimates the uncertainty on average. The mean predicted uncertainty on α\alpha, which all models significantly over-estimate, is dominated by clusters from charged particles with α\alpha close to 90∘90^\circ. These charge clusters span only a few pixels in the xx-direction, providing very little shape information for the neural network to extract and resulting in large σα\sigma_\alpha. The value of σβ\sigma_\beta is more accurately estimated because clusters close to β=90∘\beta= 90^\circ span more pixels due to the smaller pixel pitch in the yy-direction.

The progression from idealized to realistic models reveals which hardware constraints have the largest impact on physics performance. Although models operating on many time frames of input data cannot be implemented on-ASIC due to power constraints, the time evolution of the charge cluster is clearly rich in physics content: most models trained with two time frames have 30-40% worse resolution than their counterparts trained on 20 time frames, with a few of the angular predictions degrading by more than 60%. Applying the optimal thresholds for two-bit digitization typically results in only 5-10% worse resolution than training the same models with electron-level precision. Finally, the quantization of the neural network parameters introduces a shift in the mean of the residual distribution for some output features, with the Conv2D models experiencing the largest bias.

Parameter estimation without ML

For the sake of comparison, xx, yy, α\alpha, and β\beta are also calculated using non-ML methods. The integrated cluster charge after 4 ns, which corresponds to the final time frame in the simulated dataset, is digitized with the optimal thresholds obtained by the transformer (Section V) and used as input to these algorithms. The performance of the non-ML algorithms is compared to the MLP Full model with two-bit input digitization and quantized weights and biases (red upward triangles in Figure 4). Comparison to the MLP Slim model yields similar conclusions for xx, yy, and β\beta.

The xx and yy predictions of the MLP Full model are compared to two non-ML algorithms: Barycenter and LocalReco. The Barycenter algorithm uses a weighted average of the charge cluster projected onto the respective axis. The value xbaryx_{\mathrm{bary}} obtained from this weighted average corresponds directly to the predicted xx position, while an additional correction is applied to ybaryy_{\mathrm{bary}} to account for the deflection of charge carriers by the magnetic field (Lorentz drift). The predicted yy position is

y=ybary+Δy2(7)y = y_{\mathrm{bary}} + \frac{\Delta_y}{2} \tag*{(7)}

where Δy=Ttan⁡ΘL\Delta_y = T \tan\Theta_L for sensor thickness TT and Lorentz angle ΘL\Theta_L.

The LocalReco algorithm corresponds to the local reconstruction that CMS employs offline to determine the position of a hit in the pixel detector [16]. Like the Barycenter algorithm, LocalReco calculates xx and yy from the charge cluster projected onto the respective axis. The LocalReco prediction for the xx position of a hit is

x=QLx−QFxQLx+QFx⋅∣Tcot⁡α∣−(xL−xF)2+xF+xL2,(8)x = \frac{Q_L^x - Q_F^x}{Q_L^x + Q_F^x} \cdot\frac{\lvert T \cot\alpha\rvert- (x_L - x_F)}{2} + \frac{x_F + x_L}{2}, \tag*{(8)}

where QFxQ_F^x (QLxQ_L^x) is the amount of charge collected in the first (last) pixel of the charge projection, and xFx_F (xLx_L) is the xx-coordinate of the boundary between the first and second (next-to-last and last) pixels in the projection. The LocalReco prediction also depends on the value of α\alpha, which in offline analysis would be determined from a track fit to multiple pixel layers. For the comparison presented here, perfect knowledge of α\alpha is assumed. The LocalReco prediction for the yy position of a hit is analogous to (8) with an additional correction for Lorentz drift:

y=QLy−QFyQLy+QFy⋅∣Tcot⁡β+Δy∣−(yL−yF)2+yF+yL2+Δy2.(9)y = \frac{Q_L^y - Q_F^y}{Q_L^y + Q_F^y} \cdot\frac{\lvert T \cot\beta+ \Delta_y\rvert- (y_L - y_F)}{2} + \frac{y_F + y_L}{2} + \frac{\Delta_y}{2}. \tag*{(9)}

Here, QFyQ_F^y (QLyQ_L^y) is the amount of charge collected in the first (last) pixel of the charge projection, and yFy_F (yLy_L) is the yy-coordinate of the boundary between the first and second (next-to-last and last) pixels in the projection. As above, Δy\Delta_y is a correction accounting for Lorentz drift.

Figure 5 shows the xx and yy residuals for the MLP Full model and the Barycenter and LocalReco algorithms. Comparing the performance of the Full MLP model to LocalReco yields a striking result: the simple on-ASIC network can estimate xx and yy from a single pixel layer with comparable accuracy to the offline reconstruction, which relies on multiple pixel layers. The ML model also significantly outperforms the Barycenter calculation for both xx and yy. Both non-ML methods introduce a large average bias in the yy parameter compared to the ML model: Rˉy=−0.70\bar{R}_y = -0.70 and −0.81-0.81 microns for Barycenter and LocalReco, respectively, compared to only −0.1-0.1 microns for MLP Full.

Figure 5. Comparison of the residuals for xx and yy between the Full MLP model and non-ML algorithms. The non-ML algorithms labeled as “optimistic” incorporate information that is not directly available on the ASIC.

The α\alpha and β\beta residuals for the MLP Full model are compared to a non-ML Geometric method. The Geometric method for estimating α\alpha uses the size of the charge cluster projected onto the xx-axis:

∣cot⁡α∣=(wx−1)pxT,(10)\lvert\cot\alpha\rvert= (w_x - 1)\frac{p_x}{T}, \tag*{(10)}

where wxw_x is the size of the projected charge (in pixels), pxp_x is the pixel xx-pitch, and TT is the sensor thickness. This provides an estimate of the absolute value of the angle, and perfect knowledge of the sign of α\alpha is assumed for this comparison. For charge clusters spanning multiple pixels in the xx-direction, the sign of α\alpha can be reliably determined by comparing the two time frames used as input to the training, but this is an optimistic assumption for small clusters. An analogous Geometric calculation is performed to estimate β\beta from the yy-projected cluster size, but is found to perform poorly without any correction for Lorentz drift. A more precise calculation of β\beta applies a correction to account for changes in the size of the cluster yy-projection due to Lorentz drift:

∣cot⁡β∣=(wy−1)pyT+{Ttan⁡ΘL,β<π+ΘL,0,β=π+ΘL,−Ttan⁡ΘL,β>π+ΘL(11)\lvert\cot\beta\rvert= (w_y - 1) \frac{p_y}{T} + \begin{cases} T \tan\Theta_L, & \beta< \pi+ \Theta_L, \\ 0, & \beta= \pi+ \Theta_L, \\ -T \tan\Theta_L, & \beta> \pi+ \Theta_L \end{cases} \tag*{(11)}

The sign of the Lorentz drift correction depends on how β\beta compares to π+ΘL\pi+ \Theta_L, which cannot be well estimated geometrically from the charge cluster. For the comparison presented here, perfect knowledge of both the sign of β\beta and the sign of β−π−ΘL\beta-\pi-\Theta_L (highly idealized) is assumed. Figure 6 shows the α\alpha and β\beta residuals for the MLP Full model and the Geometric algorithms. Again the comparison between the MLP Full model and the non-ML algorithm is striking: the ML model obtains better performance in both α\alpha and β\beta than the Geometric method, despite the inclusion of highly optimistic assumptions in the Geometric calculation. The ML model gives better α\alpha resolution in the core of the distribution, but exhibits longer tails than the Geometric method. The Geometric β\beta calculation without the Lorentz drift correction (blue) exhibits poor performance. The Full MLP model gives similar resolution to the Lorentz-drift corrected geometric algorithm (purple) and has a lower average bias: R‾β=+0.6∘\overline{R}_{\beta}=+0.6^{\circ} compared to −1.1∘-1.1^{\circ}.

Figure 6. Comparison of the residuals for α\alpha and β\beta between the Full MLP model and non-ML algorithms. The non-ML algorithms labeled as “optimistic” incorporate information that is not directly available on the ASIC.

ASIC Synthesis

We followed a standard codesign workflow to translate the neural networks described in § 4 into low-latency hardware [30]. The floating-point TensorFlow/Keras model implementations described were used as the initial model definition and training environment, providing a reference implementation for the subsequent quantized design. Then we ran quantization-aware training using QKeras to introduce fixed-point numerical precision as a trainable design choice while minimizing accuracy loss [31]. Finally, we used hls4ml to translate the trained quantized model into C++ for high-level synthesis, enabling an iterative optimization loop between physics performance and hardware metrics such as latency, throughput, and resource usage [32, 33].

Figure 2 reports the fixed-point format used for weights and biases on the right-hand side of each layer. We use the notation fixed<W,I>, where WW is the total bit width and II is the number of integer bits, including the sign bit. The weights and biases of the convolutional layers were quantized using fixed<4,1>, corresponding to a representable range of [−1,1−1/8][-1,1-1/8] with resolution 1/81/8, while the weights and biases of the dense layers used fixed<8,1>, corresponding to a representable range of [−1,1−1/128][-1,1-1/128] with resolution 1/1281/128. These formats were selected empirically to preserve physics performance with only limited degradation relative to the floating-point baselines.

The trained QKeras models are translated into synthesizable C++ using hls4ml. The generated code is synthesized with Siemens Catapult HLS [34], targeting a TSMC 28nm technology node with a clock period of 25 ns. Designs are fully unrolled to achieve an initiation interval of one clock cycle, enabling continuous inference at each LHC bunch crossing. Profile-guided optimization is used to determine the bit widths of the accumulator and intermediate buffer, imposing a mean squared error per-layer below 10−410^{-4} relative to the QKeras fixed-point reference. After HLS, we perform validation and confirm that the hardware implementation preserves the regression performance of the quantized model.

Table I summarizes the HLS synthesis results for all models. All designs achieve a latency of two clock cycles, corresponding to 50 ns, and an initiation interval of one clock cycle, allowing one new inference every 25 ns and meeting the system requirements. The designs also meet the 25 ns timing constraint with substantial implementation headroom: the timing slack ranges from 14.33 ns to 16.62 ns, corresponding to a margin of 57–66% of the clock period. This margin provides useful headroom for subsequent physical-design effects, including routing and clock-tree insertion. However, timing closure under worst-case operating conditions must be confirmed through post-layout analysis. The Slim Conv2D implementation is the most compact overall at 0.2880 mm2^{2}. The Full MLP implementation is substantially smaller than the Full convolutional models despite its higher paparameter count, suggesting that implementation area depends strongly on the architecture and resulting hardware dataflow.

Conclusion

We have presented a suite of compact neural network algorithms that extract the kinematic features of a charged particle traversing one layer of a silicon tracking detector. Using the ionization signature in an array of pixels, these networks extract the incident particle’s position and crossing angles, as well as uncertainties on these quantities. The networks are optimized for implementation on-ASIC and are synthesizable in 28 nm CMOS, meeting system requirements for area and latency. This demonstrates a new capability of intelligent sensing that arises from embedding probabilistic ML directly into the data acquisition chain under extreme resource constraints. Moreover, we demonstrate the first joint optimization of signal digitization thresholds and neural network weights to achieve optimal physics performance.

The performance of each model is evaluated based on the residual distributions of the predicted variables. The best performance of each model is obtained by training on the collected charge sampled at twenty 200 ps intervals, indicating that the time evolution of the charge cluster is rich in physics information. However, ASIC power requirements limit the sampling rate, and the models proposed for on-chip implementation operate on the collected charge at two time points. The two-bit digitization of the input charge and the quantization of the neural network weights and biases also result in worse resolution for all parameters, but the effect is small compared to the reduction of input data from twenty to two time frames.

A selected model is compared to non-ML methods for reconstructing particle kinematics. The non-ML algorithms incorporate highly optimistic assumptions, including perfect knowledge of data external to the sensor. The ML model nevertheless outperforms all non-ML models while remaining sufficiently small and efficient for implementation within the pixelated area of an ASIC. The on-chip ML algorithms thus yield novel sensing capabilities.

This work illustrates how ML can be integrated at the earliest stages of data creation. It provides a concrete example of probabilistic inference and uncertainty estimation under extreme constraints on numerical precision, latency, and power, a regime that remains underexplored in mainstream ML benchmarks.

The results highlight two complementary advances. First, physics quantities can be extracted directly at the sensor edge with an accuracy that matches or surpasses conventional reconstruction. Second, co-design tools and workflows for training, quantization-aware optimization, and hardware synthesis are readily adaptable to a wide

range of scientific instruments. Similar constraints arise in cryogenic, space-based, and high-radiation environments, where end-to-end co-design of sensing, digitization, and inference offers a pathway toward intelligent instruments that maximize scientific return under fixed resource budgets.

Limitations and future work

Several limitations of this study suggest directions for future work. The training dataset can be made more hardware-realistic by, for example, modeling the effects of the CSA and ADC on the collected charge cluster. We can explore structured pruning or sparsification to further reduce resource usage of the ML models. And although HLS demonstrates feasibility, full hardware validation remains an essential next step. Our results indicate that the time evolution of charge carries significant information, and extending our models to incorporate richer time structure will be important as readout technologies evolve. The results presented here are based on HLS synthesis, for which power estimates are approximate: pre-layout tools lack switching-activity annotation and omit clock distribution, local buffering, and the analog front-end and ADC. The selected architectures and numerical formats were chosen to limit expected digital power consumption; however, power compliance cannot be established from the present HLS study and will require post-layout characterization. This study also omits radiation-aware synthesis, irradiation testing, and an evaluation of single-event upsets in stored configuration parameters and network weights, which are left as future work. Nevertheless, the target 28 nm CMOS process has demonstrated favorable total ionizing dose tolerance in HL-LHC-oriented studies, and prototypes have been fabricated in the same node [35]. The present study also does not account for radiation damage to the sensor bulk, which alters the electric field profile and introduces charge trapping, such that the collected charge patterns evolve away from the unirradiated simulation used for training. Since both the network weights and the digitization thresholds are reconfigurable on-chip, future work could explore periodic retraining on simulations of the irradiated sensor, with updated parameters deployed over the detector lifetime. Finally, the co-design workflow developed in this work provides a valuable template for studying ML under extreme constraints beyond the specific application considered here.

Acknowledgments

The work presented in this document was conducted using the resources of the Fermi National Accelerator Laboratory (Fermilab), a U.S. Department of Energy (DOE), Office of Science, Office of High Energy Physics HEP User Facility. Fermilab is managed by Fermi For-

Max modelsFull modelsSlim models
Conv2DConv2DConv1DMLPConv2DConv1DMLP
NN Parameters1898176727342264168226492179
Latency / II [clk]2/12/12/12/12/12/12/1
Slack [ns]14.3314.3314.3316.3616.6215.7215.72
HLS area [mm²]0.63530.61970.60670.30040.28800.34870.3350

caption: Model size, latency/initiation interval (II), slack, and area results for each model, derived from HLS targeting TSMC 28 nm and 25 ns clock period.

:::

ward Discovery Group, LLC, acting under Contract No. 89243024CSC000002.

This work was completed using computing resources at the University of Chicago’s Research Computing Center and the Fermilab Elastic Analysis Facility. We thank Burt Holzman (Fermilab) for computing support.

We acknowledge the Fast Machine Learning collective as an open community of multi-domain experts and collaborators. This community, Javier Duarte and Vladimir Loncar in particular, were important for the development of this project.

We would like to extend our sincere gratitude to Harish Jamakhandi and David Burnette from Siemens EDA for their assistance and expertise with Catapult HLS.

ML and ARD are supported by NSF AREAS PHYS-2425206 and by the A3D3 HDR Institute through the NSF award PHY-2117997. ARD is also partially supported by the Fermilab Guest & Visitor program. MSN and DJ are supported through the NSF cooperative agreement OAC-2117997 and the DOE Office of Science award DE-SC0023365. RK was supported by the Metcalf Fellowship program of the University of Chicago. ASCM was supported by the Undergraduate Research Experience Purdue - Colombia program. CM, DS, HG, and MAW are supported by NSF award PHY-2208803 and, together with AT, by DOE Office of Science award DE-SC0023715 from Funding Opportunity Announcement for Artificial Intelligence Research for High Energy Physics, DE-FOA-0002705. DS is also supported by the University Research Alliance Visiting Scholar program. JD and BW are supported by the DOE Early Career Research Program award DE-SC0026236.

DB, GDG, FF, AG, LG, JH, RL, BP, and CS are supported by Fermi Forward Discovery Group, LLC under Contract No. 89243024CSC000002 with the U.S. Department of Energy, Office of Science, Office of High Energy Physics. GDG and LG are partially supported under DOE project “HAAI: Designing Smart Detectors with a ML-to-Silicon Platform” (LAB 24-3305). GDG and BP are also supported by the U.S. Department of Energy, Office of Science, Offices of High Energy Physics and Advanced Scientific Computing Research, as part of the Co-design and Heterogeneous Integration in Microelectronics for Extreme Environments (CHIME) Microelectronics Science Research Center (MSRC) (DOE Lab Announcement No. LAB 24-3320). FF, GDG, BP, and NT are also supported by the DOE Early Career Research Program.

KFD and EH are supported by the NSF CAREER Program through award 2443370, and KFD is additionally supported by the Neubauer Family Assistant Professor Program. EY is supported by the University of Chicago’s Quad Undergraduate Research Scholar program, and DA is supported by the University of Chicago’s Sachs Fellowship.

MS and PM are supported by NSF award PHY-2310072. NM is supported by the Fermilab LHC Physics Center (LPC) Distinguished Researcher award. JP and KU are supported by DOE award DE-SC0010005.

System design considerations

In order to realize improvements from the proposed on-device pixel cluster reconstruction, it is necessary to consider the system that would be required to extract and analyze this data. Smartpixels generates a stream of reconstructed pixel clusters with positional and angular data at the rate of data creation. The clearest use case for this data is to provide this information to a real-time (Level-One, L1) trigger required to control output data rates in an experiment. Real-life examples of this can be found in the upgraded ATLAS or CMS detectors at the CERN HL-LHC, where CMS is building a L1 track trigger. Introducing pixel information into these systems has the potential to greatly improve their performance, but that information must fit within the capabilities of experimental infrastructure such as cooling, powering, and data transfer.

Because a single inference engine processes one cluster per clock cycle, multiple engines or spatially distributed processing blocks would be required to sustain the full cluster rate of a sensor. The corresponding system-level area, routing, buffering, and power costs are not included in the single-model HLS results and will be addressed in future implementation studies.

To estimate how much cluster information we can send to a real-time trigger system we begin with the expected cluster flux upon the innermost layer of the CMS pixel detector: 10 clusters per cm² per proton-proton bunch crossing and consider one bunch crossing. This cluster density is derived from GEANT simulation with full out-of-time pileup simulated over a period of 20 bunch crossings. Taking the average cluster yield per bunch-crossing we assume a 16-bit word is used to encode the physics information of each cluster to yield an average expected data rate. While this 16-bit word does restrict the amount of information that can be saved per cluster, it is enough to encode meaningful position and bending angle information for reconstructed track stubs. Then to estimate the maximum sustainable data rate in a streaming readout system we consider the five-standard-deviations upward fluctuation in the number of clusters compared to the expected Poisson mean. These calculations are summarized in tbl:2. It is important to note that using the filtering and regression capabilities of smartpixels we are able to reduce the bandwidth required to read out a pixel sensor at the HL-LHC by a factor of 10.

QuantityValue
Phase 2 Max. Avg. Pixel-Cluster Density, 200 PU, r=3.3r = 3.3 cm10 cm−210\ \mathrm{cm}^{-2}
Phase 2 Pixel Sensor Area3.61 cm23.61\ \mathrm{cm}^{2}
HL-LHC Bunch Spacing25 ns25\ \mathrm{ns}
Max. Avg. 40 MHz Bandwidth per Phase 2 sensor (+5 S.D.), reading out active pixels no compression72.2 (132.2) Gbps
Smartpixels data reduction factor from pTp_T filter0.25
Avg. number of active pixels per cluster, 200 PU, r=3.3r = 3.3 cm5
Max. Avg. 40 MHz Bandwidth per smartpixels sensor (+5 S.D.), 16 bits read out per cluster no compression5.77 (10.58) Gbps

Table II. Inputs and calculations for the HL-LHC CMS pixel detector output data rate at 40 MHz.

Modern silicon photonics encoders operate at 30 Gbps and above [36], and radiation hardness has been demonstrated for 30 Gbps encoders to HL-LHC expected doses. Moreover, wavelength multiplexing can be employed to encode multiple streams on a single fiber, making 100 Gbps readout rates per sensor possible, or similarly yielding ultra-light readouts by using a single 30 Gbps encoder per sensor and stacking them on the same readout fiber. This then implies that it is possible to stream this pixel data to real-time processing facilities like the CMS or ATLAS Level-One trigger systems and to then exploit the additional precise measurements made by the pixel detector at trigger level. Our initial estimates of bandwidth therefore demonstrate that novel triggering strategies are made possible by smartpixels together with silicon photonics and the corresponding physics impacts should be studied.

References

  1. [1]ATLAS Collaboration, The ATLAS Experiment at the CERN Large Hadron Collider, JINST 3, S08003.
  2. [2]CMS Collaboration, The CMS experiment at the CERN LHC. The Compact Muon Solenoid experiment, JINST 3, S08004.
  3. [3]K. Einsweiler and L. Pontecorvo (ATLAS), Technical Design Report for the ATLAS Inner Tracker Pixel Detector, Tech. Rep. CERN-LHCC-2017-021, ATLAS-TDR-030 (2017).
  4. [4]D. Contardo, M. Klute, J. Mans, L. Silvestris, and J. Butler (CMS), Technical Proposal for the Phase-II Upgrade of the CMS Detector, Tech. Rep. CERN-LHCC-2015-010, CMS-TDR-15-02 (2015).DOI
  5. [5]A. Ryd and L. Skinnari, Tracking for the HL-LHC, Annual Review of Nuclear and Particle Science 70, 171–195 (2020), arXiv:2010.13557.DOI
  6. [6]C. Bishop, Mixture density networks, Working Paper (Aston University, 1994).
  7. [7]P. Coussy and A. Morawiec, High-Level Synthesis: From Algorithm to Digital Circuit (Springer, 2009).DOI
  8. [8]The Phase-2 Upgrade of the CMS Tracker, Tech. Rep. (CERN, Geneva, 2017).
  9. [9]G. Alimonti et al. (RD53), RD53 Pixel Readout Integrated Circuits for ATLAS and CMS HL-LHC Upgrades, JINST 20 (03), P03024.DOI
  10. [10]G. Deptuch, D. Christian, J. Hoff, R. Lipton, A. Shenai, M. Trimpl, R. Yarema, and T. Zimmerman, A Vertically Integrated Pixel Readout Device for the Vertex Detector at the International Linear Collider, IEEE Transactions on Nuclear Science 57, 880 (2010).
  11. [11]R. Lipton, 3D Technology for Intelligent Trackers, JINST 5, C01006.
  12. [12]J. Yoo et al., Smart Pixel Sensors: Towards On-Sensor Filtering of Pixel Clusters with Deep Learning, Machine Learning: Science and Technology 5, 035047 (2024).
  13. [13]B. Parpillon et al., Smart Pixels: In-Pixel AI for On-Sensor Data Filtering, in 2024 IEEE Nuclear Science Symposium (NSS), Medical Imaging Conference (MIC) and Room Temperature Semiconductor Detector Conference (RTSD) (2024) arXiv:2406.14860 [physics.ins-det].arxiv.org/abs/2406.14860
  14. [14]S. R. Kulkarni et al., On-Sensor Data Filtering using Neuromorphic Computing for High Energy Physics Experiments, in ICONS ’23: Proceedings of the 2023 International Conference on Neuromorphic Systems, ACM International Conference Proceeding Series (Association for Computing Machinery, 2023) pp. 3:1–3:8.arxiv.org/abs/2307.11242
  15. [15]Y. Chen et al., Optimal use of Charge Information for the HL-LHC Pixel Detector Readout, Nuclear Instruments and Methods in Physics Research Section A 902, 197 (2018), arXiv:1710.02582 [physics.ins-det].DOI
  16. [16]M. Swartz, D. Fehling, G. Giurgiu, P. Maksimovic, and V. Chiochia, A new technique for the reconstruction, validation, and simulation of hits in the CMS Pixel Detector, in Proceedings of Science: The 16th International Workshop on Vertex detectors, Vol. 057 (2007) p. 035.DOI
  17. [17]D. Shekar et al., Smartpixels 16 × 16 datasets, 10.5281/zenodo.18472791 (2026).
  18. [18]Silvaco TCAD, https://silvaco.com/tcad/, accessed: 2025-07-25.
  19. [19]M. Swartz, A Detailed Simulation of the CMS Pixel Sensor, Tech. Rep. CMS-NOTE-2002-027 (2002).
  20. [20]M. Abadi et al., TensorFlow: Large-scale machine learning on heterogeneous systems, https://www.tensorflow.org/ (2015).arxiv.org/abs/1603.04467
  21. [21]F. Chollet et al., Keras, https://github.com/fchollet/keras (2015).
  22. [22]D. P. Kingma and J. Ba, Adam: A method for stochastic optimization (2014).arxiv.org/abs/1412.6980
  23. [23]T. Dozat, Incorporating Nesterov Momentum into Adam, in Proceedings of the 4th International Conference on Learning Representations, pp. 1–4.
  24. [24]A. G. Howard, M. Zhu, B. Chen, D. Kalenichenko, W. Wang, T. Weyand, M. Andreetto, and H. Adam, MobileNets: Efficient convolutional neural networks for mobile vision applications (2017), arXiv:1704.04861.arxiv.org/abs/1704.04861
  25. [25]F. Chollet, Xception: Deep Learning with Depthwise Separable Convolutions, in Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR) (2017) pp. 1251–1258, arXiv:1610.02357.arxiv.org/abs/1610.02357
  26. [26]C. C. Cottini, E. Gatti, G. Giannelli, and G. Rozzi, Minimum noise pre-amplifier for fast ionization chambers, Il Nuovo Cimento 3, 473 (1956).
  27. [27]Cadence Custom IC / Analog / RF Design, https://www.cadence.com/en_US/home/tools/custom-ic-analog-rf-design.html, accessed: 2025-09-04.
  28. [28]A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, L. Kaiser, and I. Polosukhin, Attention is all you need (2023), arXiv:1706.03762.
  29. [29]A. Dosovitskiy, L. Beyer, A. Kolesnikov, D. Weissenborn, X. Zhai, T. Unterthiner, M. Dehghani, M. Minderer, G. Heigold, S. Gelly, J. Uszkoreit, and N. Houlsby, An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale (2021), arXiv:2010.11929.arxiv.org/abs/2010.11929
  30. [30]F. Fahim et al., hls4ml: An Open-Source Codesign Workflow to Empower Scientific Low-Power Machine Learning Devices, in Proceedings of TinyML Research Symposium (ACM, 2021) pp. 1–10, arXiv:2103.05579.arxiv.org/abs/2103.05579
  31. [31]C. N. Coelho, A. Kuusela, S. Li, H. Zhuang, J. Ngadiuba, T. K. Aarestad, V. Loncar, M. Pierini, A. A. Pol, and S. Summers, Automatic heterogeneous quantization of deep neural networks for low-latency inference on the edge for particle detectors, Nature Machine Intelligence 3, 675 (2021), arXiv:2006.10159.DOI
  32. [32]FastML Team, hls4ml, https://github.com/fastmachinelearning/hls4ml (2021).
  33. [33]J. Duarte et al., Fast inference of deep neural networks in FPGAs for particle physics, JINST 13 (07), P07027, arXiv:1804.06913.DOI
  34. [34]Siemens, Catapult HLS, https://eda.sw.siemens.com/en-US/ic/ic-design/high-level-synthesis-and-verification-platform.
  35. [35]B. Parpillon, A. Badea, D. Shekar, C. Gingu, G. D. Guglielmo, T. Deline, A. Quinn, M. Ronchi, B. Weiss, J. Dickinson, J. Yoo, C. Mills, D. Abadjiev, A. Nicholas, E. Howard, C. Kumar, E. You, M. Littmann, K. DiPetrillo, A. R. Das, M. Liu, D. Jiang, M. S. Neubauer, M. Swartz, P. Maksimovic, A. Bean, R. Silvestre, J. Pearkes, K. Ulmer, N. Manganelli, C. Syal, D. Berry, N. Tran, L. Gray, and F. Fahim, In-pixel integration of signal processing and ai/ml based data filtering for particle tracking detectors (2025), arXiv:2510.07485.
  36. [36]M. Newcomer, J. Ye, A. Paramonov, M. Garcia-Sciveres, and A. Prosser, Fast (optical) links (2022), arXiv:2203.15062.arxiv.org/abs/2203.15062

Paper details

vlnc:W_ru2whe5d
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 0

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Physics and Astronomy

Not recorded for this paper

View statement
Looking for related papers…
Contents