betaFeedback

WorksPhysics and Astronomy

Charged Particle Tracking with Machine Learning on FPGAs

Abstract

The determination of charged particle trajectories (tracking) in collisions at the CERN Large Hadron Collider (LHC) is one of the most important aspects for event reconstruction at hadron colliders. This is especially true in the high conditions expected during the future high-luminosity phase of the LHC (HL-LHC) where the number of interactions per beam crossing will increase by a factor of five. Deep learning algorithms have been successfully applied to this task for offline applications. However, their study in hardware-based trigger applications has been limited . In this paper, we study different algorithms for two different steps of tracking and show that such algorithms can be run on field-programmable gate arrays (FPGAs).

Introduction

Charged-particle tracking is one of the most important aspects for event reconstruction at hadron colliders such as the LHC [1]. Silicon-based, high-granularity tracking sensors detect ionization charge deposited by particles as they propagate through the magnetic field of the detector. Tracking algorithms use this information to measure the curvature of particle trajectories and thus deduce the particles’ charge and momentum. Precise tracking is an indispensable tool for any collider experiment. Efficient identification of electrons and muons, based on tracking, is necessary to separate new phenomena from the overwhelming background. The capability to reconstruct detached vertices is an essential tool, for example, for identifying b-jets in all cases when the new particles have a preferential decay to heavy quarks, like the Higgs boson. In particular track reconstruction in the real-time trigger systems is critical to fully exploit the physics capabilities of hadron-collider experiments such as ATLAS [2], enabling an early rejection of background and more signal-like events written to tape. The hardware (software) trigger system at current LHC experiments must make physics decisions within a few microseconds (seconds). Events that do not have a positive trigger decision are not written on tape and are lost. Field Programmable Gate Arrays (FPGAs) are the preferred technology for these high-throughput low-latency situations, as current CPU devices are simply too slow to meet experimental requirements. The flexibility offered by FPGAs is particularly important as they can be updated to meet new experimental needs and can incorporate the latest technological advances. This flexibility will be even more important at the next generation colliders, such as the High-Luminosity LHC (HL-LHC [3]) or FCC-hh [4] which will bring considerable performance challenges to particle tracking. The average number of interactions per beam crossing will increase by a factor of five (20 for future colliders) compared to current LHC conditions and result in a similar increase in the number of charged particles and hence detector occupancy.

Traditional tracking algorithms scale quadratically or worse with detector occupancy. Under reasonable assumptions on the evolution of CPU performance and cost tracking algorithms will need to become one order of magnitude faster and run in parallel on one order of magnitude more processing units (cores or threads). Software based algorithms are therefore not suitable for real-time triggering in low-latency environments. The targeted latency can be achieved by implementing advanced machine learning algorithms for track reconstruction in FPGAs to perform tracking at high data rates and low latency. In particular Deep neural networks (DNNs), such as convolutional neural networks (CNNs) [5], recurrent neural networks [6], have the stunning capability of analyzing large amount of data and/or making decisions by automatically learning features from data rather than a handcrafted approach. DNNs have demonstrated excellent performance in areas such as computer vision, natural language processing, and robotics. While deep learning techniques have been used for decades in HEP, their deployment for very low-latency (sub-microsecond) real-time particle tracking is just now being studied in depth, so there are many open questions about the best way to incorporate them. RNNs [7] and Graph Neural Network (GNNs) [8, 9, 10, 11] have both shown great potential for identifying candidate tracks.

In this paper we explore the applicability of several advanced machine learning algorithms to different steps of tracking and compare their efficiency. One example of FPGA implementation is also shown.

Machine Learning for Tracking

The current generation tracking methods [12] divides the problem into stages. These stages are: hit clustering, track seeding, track extrapolation, track fitting and possibly removal of fake tracks. The hit clustering estimates the charge deposit and position parameters of particles that intersect with multiple pixels on a detector layer. Track seeding combines clusters in doublet or triplet seeds where each seed provides an initial track direction, origin. The track extrapolation stage adds more hits to the seed by looking for matching hits along the extrapolated trajectory. Finally a track fitting stage fits a trajectory through the track hits to assess the track quality and measure the particle’s physical and kinematic properties (charge, momentum, origin, etc). Current bottlenecks for offline tracking are the track seeding and extrapolation stage. In this paper two different algorithms are studied for the track extrapolation part and the removal of fake and duplicate tracks which are created at the track building stage.

Extrapolator

Traditional track extrapolation methods rely on a Kalman Filter (KF) to locate hits along the trajectory of charged particles in a detector [13]. The Kalman Filter makes next-hit predictions via a state equation which propagates charged particles through potentially non-uniform magnetic fields and detector materials. The predictions are combined with per hit measurements to progressively refine the predictions along a track. A series of matrix operations including addition, multiplication, and inversion are required by the Kalman filter at each iteration, making KF algorithms ill-suited for CPU driven computation. Some of the related problems may be addressed by heterogeneous computing strategies [14]. Additional constraints arise however, as magnetic field configurations and detector geometries must be stored and continually accessed in order for the KF to operate. The memory consumption of these steps further impedes the latency of KF tracking algorithms and strains memory limited devices such as FPGAs.

Neural network based approaches to tracking provide natural solutions to these problems. Neural network architectures based on the multi-layer perceptron (MLP) rely on a series of matrix multiplications to perform tasks and so are amenable to firmware implementations on accelerating devices such as FPGA. Additionally, many feed forward neural networks have been shown to be universal approximators, and may be well suited to approximating functions such as the state equation for a charged particle propagating through a detector [15]. NNs also naturally address the issue of magnetic field and detector geometry storage and accessing. One of the many strengths of neural networks is their ability to extract features from a dataset and incorporate these features into the their predictions. Given sufficient training data of particle tracks, a NN can learn the magnetic field orientation and detector geometry of a generic particle detector. This eliminates the need to store and access such information independently on a chip.

Several models were developed for track extrapolation in this paper and their performances are compared. Models are kept relatively narrow and shallow so that they may realistically fit with the resource budget of an FPGA. A description of the NNs models used is found below:

Multi-layer Perceptron (MLP)

The simplest form of a neural network is the multi-layer perceptron (MLP). Given an input vector, of size mm, x1=h1∈Rm\mathbf{x}_1 = \mathbf{h}_1 \in\mathbb{R}^{m}, we can compute the state layer vector at l+1l+1 layer hl+1∈RNl+1\mathbf{h}_{l+1} \in\mathbb{R}^{N_{l+1}}, where Nl+1N_{l+1} is the dimension of the l+1l+1 layer state space by iteratively applyg:

hl+1(t)=ϕ(Whl×hl(t)+bhl)(1)\mathbf{h}_{l+1}(t) = \phi(\mathbf{W}_{hl} \times\mathbf{h}_l(t) + \mathbf{b}_{hl}) \tag*{(1)}

where Whl\mathbf{W}_{hl} is an Nl×Nl+1N_l \times N_{l+1} weight matrix and bhl\mathbf{b}_{hl} is the bias weight, and ϕ\phi is a non-linear activation function such as ReLU, sigmoid, and tanh to generate nonlinear effects in the latent representation. The last layer of MLP is connected to the targeted output y(t)\mathbf{y}(t) by additional activation or readout function. The major advantage of the MLP is its simplicity. It is able to learn non-linear mappings, but it struggles to capture temporal or sequential dependencies of input data. The MLP used in this paper is comprised of an input layer, two hidden layers with ReLU activations, and an output layer. A tanh activation is applied to the final layer so that the outputs correspond accordingly with the scaled inputs.

Recurrent Neural Network (RNN)

Recurrent neural network (RNN) is a type of neural networks that is designed to handle sequential or time series data. The basis of RNN is learning the recurrent latent representation of the sequence or time series. Specifically, the temporal dynamics of hidden states are governed by a recurrent connection:

h(t)=ϕ(Whhh(t−1)+Whxx(t)+bh)(2)\mathbf{h}(t) = \phi(\mathbf{W}_{\mathrm{hh}}\mathbf{h}(t-1) + \mathbf{W}_{\mathrm{hx}}\mathbf{x}(t) + \mathbf{b}_{\mathrm{h}}) \tag*{(2)}

where Whh\mathbf{W}_{\mathrm{hh}} is an N×NN \times N weight matrix, Whx\mathbf{W}_{\mathrm{hx}} is an N×KN \times K weight matrix, bh\mathbf{b}_{\mathrm{h}} is the bias weight, and ϕ\phi is an activation function. The output y(t)∈RL\mathbf{y}(t) \in\mathbb{R}^{L} is mapped from the hidden state:

y^(t)=f(h(t))(3)\hat{\mathbf{y}}(t) = f(\mathbf{h}(t)) \tag*{(3)}

where ff is a readout function related to the task usually set as a feedforward neural network. For the studies presented in this paper, GRUs (Gated Recurrent Units) are chosen. These additionally contains a forget gate to cope with vanishing gradients but remains relatively simple, such that they may be effectively programmed onto an FPGA.

Bidirectional Recurrent Neural Network (biRNN)

This model is identical to the RNN, however each input sequence is processed in both the forward and backwards direction. The output of each process is concatenated together before the output activation is applied.

Echo-state Network (ESN)

The computational cost of RNN can be expensive due to its inherently sequential nature and the overhead of avoiding the vanishing gradient problem. Echo state network (ESN) [16] are designed to mitigate this.

An ESN is built by connecting input vectors to a "reservoir" of nodes via a randomly initialized weight matrix. The output from this operation is multiplied by a sparse matrix which is also randomly initialized and held fixed during training. Finally, the reservoir is passed through a trainable feed forward neural network to give the desired output. The ESN used here have a reservoir of 200 nodes with a connectivity of 10% and tanh activation.

Overlap removal

For any track reconstruction algorithm, even those that rely on Kalman Filter or Hough Transform [17, 18] or the NN based algorithms described above, combinations of hits that do not match to any truth particles are commonly created. This arise due to the large combinatorial possibilities for initial seeds from which tracks are extrapolated from or when a possible hits are searched for in the next layers. The number of ‘fake’ tracks typically scale with the density of particle in an event, and can reach as high as approximately 1000 fake tracks created for each ‘true’ track at conditions expected at the HL-LHC [19].

These fake tracks are typically rejected by performing a full track fit and performing a selection on the compatibility of the hits to originate from a potential particle traversing the detector. However, these fits are computationally expensive and require a precise description of the magnetic field and the detector geometry.

Similar to the requirements of the track extrapolator, NNs offer a simple way to condense the information such that they can be implemented on memory limited devices. Additionally, the expected time required to evaluate an NN on a collection of hits is significantly less than that of a full track fit. This allows a significant fraction of fake hit combination to be rejected before a full track fit is performed.

Samples

The simulated samples and tracking data used in study are produced using the A Common Tracking Software Toolkit (ACTS) [20] using its fast track simulation engine. A generic detector geometry, OpenDataDetector (ODD) [21], is used (shown in Figure 2. It consists of the typical silicon technologies that are expected to be used at HL-LHC detectors. The detector has barrel and end-cap sections, with 4 (7) layers of pixel sensor placed closest to the interaction point in the barrel (end-cap) region. These are subsequently followed with 4 layers of short-strip silicon sensors and 2 layers of double-sided long-string silicon sensors in both regions.

Figure 2. The predicted hit coordinates output by an RNN where the preceding three true hits are used as input, are overlaid on the ACTS detector. Tracks are required to have at least 8 hits within the barrel.

Various processes are simulated using this setup. For training the various ML algorithms, predominately events with single muons with a flat pTp_{\mathrm{T}} distribution above 1 GeV and no restriction on η\eta, ϕ\phi of the track are used. These samples are supplemented with simulated proton-proton collision events, where the hard-scatter process is forced to only create a top anti-top pair. The decay of these particles provides a large variety of charged particles across different pTp_{\mathrm{T}} regions. In addition to being used in the training dataset, this sample is used to study the number of hits, clusters and roads that the system will encounter in data-taking.

The single muon and top anti-top events are also overlaid with soft QCD “pileup” vertices to simulate the highly dense environment observed in proton–proton collision. The average number of vertices, <μ><\mu>, are set to 40 and 200 to simulate the current LHC condition and the future expected HL-LHC condition respectively.

Track reconstruction

The first step of track reconstruction is the formation of hit clusters from raw hit data, the goal being to group adjacent hits and average their positions to result in one coordinate per detector layer. These clusters are then used to perform track reconstruction, via a first high-speed but low precision step of track seeding. In this paper, we compare the performance of a track seeding algorithm under investigation by the ATLAS [19], known as the Hough Transform [17, 18], with track reconstruction performed by neural networks.

Hough Transform

The Hough Transform implemented here was inspired by work done for the EF Tracking Amendment of the ATLAS Trigger and DAQ upgrade Technical Design Report [19]. Most concepts implemented there – detector layers used, rough size of accumulator and bin sizes in ϕ0\phi_0 and qA/pTq_A/p_T, use of hit extension in inner layers for larger d0d_0 acceptance, zz-slicing for reducing accumulator occupancy – are also adopted here. However, it was prepared for the under-construction ATLAS ITK, which has a different detector geometry to the ODD detector, so several aspects of it are modified. Full details can be found in Appendix § 10.

As identified in Ref [19] and also with the implementation used for the results in this paper, in order to obtain a high efficiency for track reconstruction with the Hough Transform, the selection requirements must be sufficiently loose. This generates a large number of fake tracks. One avenue to improve the purity of the algorithm, are the studies presented in § 5. A second way to improve this is to perform the track reconstruction itself with NNs, as described in § 4.2.

Track Reconstruction with NNs

A set of NN’s of increasing complexity are trained with the goal of finding the next hit position along a track, given initial hits along the track. The models used for this study are presented in Table 1. Each NN is given three sequential hits as input. The input features for each hit are the hit’s x/y/zx/y/z coordinate, with each element scaled to be O(1), as well as a one-hot-encoded vector specifying the detector volume and layer where the hit is located. The NN’s are pre-trained with mean-square-error loss function with the corresponding next hit’s cartesian coordinates as a target,

NN TypeModel ArchitectureTraining time per epoch [s]σ\sigma of residual ρ\rho [mm]ϕ\phi [mrad]zz [mm]
MLP14 x 32 x 32 x 32 x 358.297.4
RNN14 x 32 x 32 x 39.58.276.7
biRNN14 x 32 x 32 x 3157.976.5
ESN14 x 200 x 36212511

Table 1. Comparison of various neural network model performance attributes. The model architecture is read as the number of nodes in a given successive layer.

MSE=1n∑i=1n(ri−r^i)2(4)MSE = \frac{1}{n}\sum_{i=1}^{n}(r_i-\hat{r}_i)^2 \tag*{(4)}
L=MSE+An∑i=1n(ρi−ρ^i)2(5)\mathcal{L} = MSE + \frac{A}{n}\sum_{i=1}^{n}(\rho_i-\hat{\rho}_i)^2 \tag*{(5)}

All models are trained over a set of nearly 3 million tracks, segmented into three hit sections used as input. Each track is comprised of only a single hit per layer. In cases when there are multiple hits in a single layer, the hit closest to the origin is used to construct a clean track. A batch size of 4096 is used for each training and the models are trained until the loss values converge over a set of validation samples. A RelU activation as applied to each hidden layer. Outputs are passed to a tanh function to ensure the outputs are O(1) in accordance with the normalization scheme.

The performance of the various NN is evaluated by comparing the residual between the true hit coordinates and the predicted coordinated shown in Figure 1 and summarized in Table 1. For a similar architectural complexity, the MLP, RNN and biRNN NN have better performance when compared to the ESN NN. Additional, to cross-check that NN have learned the detector geometry during the training, the NN predicted hits using the RNN model are overlaid on the various detector geometry as show in Figure 2. For most predicted hits, the coordinates lie within a detector element, with only a small fraction of hits lying outside the elements in the ρ\rho coordinate.

Image not extracted

Figure 1. Overlaid residual distributions in cylindrical coordinates from the four neural networks. The standard deviation σ\sigma and mean μ\mu of each distribution are cited in the legend

Extrapolation Algorithm

The extrapolation algorithm starts by operating on seed tracks, which are comprised of three hits in the inner-most layers. The NN uses these hits to predict the coordinate of the next hit along each track. A new track is constructed for each hit that lies within a given radius of the predicted coordinate. This radius is informed by the uncertainty of each NNs predictions at any given detector region. Three constant values of 10mm, 15mm, and 20mm are used throughout this paper as points of comparison.

The most recent three hits along each extrapolated track are iteratively used as input to the NN, and tracks are constructed this way until either:

  • there are no hits in the detector within range of the predicted hit, or

  • the edge of the detector is reached.

Many of the duplicate and fake tracks are created through this process are rejected via the method described in § 5.

Performance

To evaluate the performance of the extrapolation algorithm, seed tracks are constructed from the truth tracks. This simplification leads to the most straight forward method for evaluating the performance of the algorithm as it will not artificially decrease the purity of the reconstructed tracks by including the fake tracks from fake seeds. The average number of total tracks reconstructed in an event and the average number of tracks reconstructed per seed track for different uncertainty window is presented in Figure 3. The large number of combination are due to high density of hits in the detector from lower energy particles, and increases with the average pileup in the event as showing in Figure 4.

Figure 3. The average number of total extrapolated tracks and the average number of extrapolated tracks for each seed track in a event with <μ>=200< \mu>=200 pileup event for various uncertainty window size.

Figure 4. The average number of total extrapolated tracks for various pileup scenarios for a window size of 15mm.

The performance of the NN are evaluated using tracks that are contained in the barrel region of the detector, which is defined as ∣η∣<0.7|\eta| < 0.7. Both the true and extrapolated tracks are require to have a minimum of 8 hits, ensuring that they have enough energy to traverse the detector. An extrapolated track is considered "matched" to a true track if more than

50% of the hits in the extrapolated track, excluding seed hits, stem from the same particle, as every track seed is comprised of hits belonging to the true track. The NN extrapolator’s reconstruction efficiency is calculated as the fraction of truth tracks that are matched to at least one extrapolated track:

ϵextrap=NmatchedNtrue.(6)\epsilon_{\mathrm{extrap}} = \frac{N_{\mathrm{matched}}}{N_{\mathrm{true}}}. \tag*{(6)}

As the current performance is calculated using truth seeds, the overall tracking efficiency of full algorithm would be ϵseed×ϵextrap\epsilon_{\mathrm{seed}} \times\epsilon_{\mathrm{extrap}}. A few examples of matched and unmatched tracks are shown in Figure 5. The reconstruction efficiency as a function of various track parameters for the different NN algorithm is shown in Figure 6. As observed in Table 1, due to the largest expected residual between the true and predicted hits, the ESN NN has the lowest efficiency. The other three networks have a similar efficiency when the tracks originate close to the interaction point and low d0d_0 parameter. The MLP and RNN algorithm have lower performance at higher d0d_0 values, with the MLP NN showing a larger sensitivity. The pileup dependency of the MLP NN is showing in Figure 7. Across all variables, this dependency is found to be negligible.

Figure 5. Four sample seeds and corresponding extrapolated tracks in a ttˉt\bar{t} event. Fully extrapolated tracks that are matched to a true track are shown as solid red lines. Extrapolated tracks that are not matched to a true track are shown as solid blue lines. The true track corresponding to the seed of the unmatched extrapolated tracks are shown as dashed blue lines.

Figure 6. Reconstruction efficiency for different NN algorithms. Only tracks with ∣η∣<0.7|\eta| < 0.7 are considered. The true and extrapolated tracks are required to have a minimum of 8 hits. An extrapolated track is considered "matched" to a true track if more than 50% of the hits in the extrapolated track, excluding seed hits, stem from the same particle. The reconstruction efficiency is calculated as the fraction of truth tracks that are matched to at least one extrapolated track within an uncertainty window of 20mm.

Figure 7. Reconstruction efficiency overlay for different pileup conditions using an MLP NN for the extrapolation as a function of various track parameters. Only tracks with ∣η∣<0.7|\eta| < 0.7 are considered. The true and extrapolated tracks are required to have a minimum of 8 hits. An extrapolated track is considered "matched" to a true track if more than 50% of the hits in the extrapolated track, excluding seed hits, stem from the same particle. The reconstruction efficiency is calculated as the fraction of truth tracks that are matched to at least one extrapolated track within an uncertainty window of 20mm.

Track Overlap removal and fake rejection with NNs

This section describes the Neural Network built to reduce the fake tracks after the pattern recognition step. A similar strategy as the one described in Ref. [19] is used.

The model architecture used for this step is a densely connected MLP with 2 layers of 32 nodes each. The input features used are the 10 hits coordinates. If a track consists of less than 10 hits, the input features are padded with zero. The output of this NN is a single score that is related to the probability of the candidate track originating from a true particle. The final resulting architecture of this model is 30×32×32×130 \times32 \times32 \times1.

The training dataset used for this NN is based on the output of the MLP extrapolator described in § 4.2. True labelled tracks are classified as combination of hits where more than 95% of the hits originate from the same truth particle. Similarly, the fake labelled tracks are hits combination where less than 50% of the hits originate from one truth particle. Mean squared error is used as the loss function.

The implementation and training of this network was performed using both the Keras [22] and Pytorch [23] library with nominal optimization of the training hyper-parameters. As shown in Figure 8, training time required for the Pytorch implementation is typically shorter than the Keras implementation. However, Keras implementation has a lower loss value for the same number of training epochs. Similarly, a comparison of the training using CPUs and GPUs was performed. As shown in Figure 9, training using GPUs typically required a factor of 2 less time, limited by the access to the samples of data.

Figure 8. The loss and time required as a function of the training epoch for the neural network designed to perform fake track rejection and overlap removal. Implementation using Keras and Pytorch libraries are compared.

Image not extracted

Figure 9. The training time as a function of the number of epochs for the neural network designed to perform fake track rejection and overlap removal. Training using CPUs and GPUs are compared.

The final implementation of NN is done using the Keras library and the training is performed on GPU. Additionally it was observed the performance of the NN was significantly improved by:

  1. Removing the rotational symmetry through rotating the input track candidate such that the first hit is at ϕ=0\phi= 0,

  1. Scaling the hit coordinates such that max position is O(1),

  1. and finally ordering the hits with respect to the distance from the center of the detector.

The pre-processing steps are found to improve the NN performance irrespective of the algorithm used to create the hit combinations.

Application and Performance

The overlap and fake rejection setup is similarly applied as the ‘Hit-Warrior’ algorithm described in Ref. [19]. In this step, as outlined in Figure 10, if two or more tracks share N hits only the track with the highest NN score is kept to reduce overlapping tracks. Additionally, all tracks are required to have a minimum NN score to reject fake tracks.

Image not extracted

Figure 10. Left: Sketch of the overlap removal and fake rejection algorithm. If tracks share more than the specific numbers of hits, only the track with the higher NN score is kept. Right: Distribution of NN score for truth labelled and fake labelled tracks.

The output of the training NN for truth and fake labelled tracks is shown in Figure 10. The performance of this algorithm with a cut on the NN score being greater than 0.5 and overlap threshold at 8 hits is shown in Figure 11. After the application of this step, a small loss of 0.9% is observed in the truth track efficiency. However, an approximately factor of 80 reduction in total tracks is observed. The average purity of the MLP extrapolator increases from 0.9% to 70% with the application of this step.

Figure 11. Track efficiency as a function of the track parameters for true tracks and the average number of tracks reconstructed by the MLP extrapolation for a window size of 20 mm for ⟨μ⟩=200\langle\mu\rangle= 200. The Efficiency is compared after the application of the overlap and fake removal NN step.

Estimation of resources on FPGAs

To translate the NNs for the extrapolator and the overlap and fake removal step for inference on FPGA, the HLS4MLv0.6 library is used [24]. This package provides a convenient way to implement these algorithms using high level synthesis. The MLP based extrapolator is used to estimate the resource usage. The Xilinx Alveo U250 FGPA is targeted for the implementation.

To reduce the expected resources needed on a FPGA, the NNs were sparsely trained with pruning of small weights. For the translation, the reuse factor is set to 1. This implementation will provide the setup with the lowest latency with the highest resource usage. For quantization of the weight, each layer was individually optimized, with an example show in Figure 12 of the typically distributions of weight and the span of the numerical representation of those weight on the FPGA. The difference in the output predictions between the two different representation of the NN are shown in Figure 13. The final resource estimates are provided in Table 2.

Figure 12. Distributions of weights and bias for each layer of the extrapolator and overlap and fake rejection NN.

NNLatency (ns)LUT (%)FF (%)BRAM/URAM (%)DSP (%)
Extrapolator507.0.5< 0.0121
Overlap and Fake removal5018.1.< 0.0131

Table 2. Latency and resource usage on an Xilinx Alveo U250 FGPA.

Figure 13. Numerical difference in the output predictions between the original NN and the ones quantized for implementation on the FPGA for the MLP extrapolator and the overlap and fake rejection step.

Conclusion

In this paper we have presented a novel ML based approach to charged particle tracking in a generic detector geometry. A set of neural networks of various architectures are trained on particle tracks, using spatial per hit information as input to the networks. In most cases, the NNs are able to precisely approximate the dynamics of a charged particle traversing through a magnetic field within the barrel of a cylindrical particle detector. The approximated function is used to predict the hit coordinates along a track, and hits are then combinatorially matched to the predicted hit location. The overlap removal algorithm is applied to the set of produced tracks, and a second neural network prunes out fake and duplicate tracks from the remaining set. The track finding efficiency and number of generated tracks resulting from this algorithm are compared with the Hough Transform in ⟨μ⟩=0,40,200\langle\mu\rangle=0,40,200 pileup conditions. In the case of ⟨μ⟩=200\langle\mu\rangle=200, the number of tracks produced via the ML approach shows a factor 1000 reduction compared to that of the HT, at the cost of only 1%-2% in efficiency, which can be tuned according to the needs of the experiments. The resource usage for a NN implemented on an FPGA is estimated, along with the per prediction latency.

Future Work

The tracking approach outlined here is promising in both its efficiency and amenability to heterogeneous computing architectures. The next steps in developing this approach include extending predictions to the endcap layers, predicting per hit uncertainties, and optimizing the FPGA implementation of the algorithm.

Hough Transform details

This appendix describes the full details of the Hough Transform used.

The Hough Transform works by means of a coordinate transform - of a hit at (ρ,ϕ)(\rho, \phi) in the transverse plane of the tracking detector to a line (close to straight) in the (ϕ0,Aq/pT)(\phi_0, A q/p_{\mathrm{T}}) plane, describing all possible circular tracks through that point and the origin where ϕ0\phi_0 is the inclination at the origin and Aq/pTAq/p_{\mathrm{T}} is the track curvature (relating to the particle charge qq and transverse momentum pTp_{\mathrm{T}}, and uniform toroidal magnetic field absorbed into the constant AA).

Hits are thus grouped into tracks by searching for intersections of these lines, corresponding to track parameters passing through all those points in real space. This intersection search is performed by drawing the coordinate-transform lines in an “accumulator” - a 2D histogram, binned in ϕ0\phi_0 and Aq/pTAq/p_{\mathrm{T}}, and then searching for bins which exceed a threshold value.

  • ϕ0\phi_0 range: 0.4 radians wide, plus 0.1 radians overlap on each side →\rightarrow 0.6 radians total

  • q/pTq/p_{\mathrm{T}} range: -2 to 2

  • number of bins per accumulator in ϕ0\phi_0 and q/pTq/p_{\mathrm{T}}: 500

  • Detector parts: outer pixel layer, all short strip (4 layers), all long strip (2 double-layers) – 9 layers total (see Figure 14)

  • Hit extension (fill adjacent bins in ϕ0\phi_0): pixel: +2 bins, inner layer of short strip: +1 bin, rest of strip: 0

  • threshold: require 7 hits

Image not extracted

Figure 14. ACTS detector layout in the z−ρz-\rho plane, with parts not used in the Hough Transform greyed out. The red dashed lines show η=−0.7\eta=-0.7 and η=0.9\eta=0.9, and the black dashed lines example trajectories from vz=(−500,−140,140,500)v_z=(-500,-140,140,500) mm through the η=−0.7\eta=-0.7 and η=0.9\eta=0.9 accumulators.

One accumulator covering the whole detector in η\eta is too highly occupied for individual tracks to be accurately identified. Thus the detector is split up into multiple regions, according to the vzv_z and η\eta of potential track candidates – an example slicing can be seen in Figure 15.

Image not extracted

Figure 15. Example zz slicing - points are hits from events distributed along ∣vz∣<500|v_z|<500 mm, lines are the zz slices used (offset vertically for legibility). Each vzv_z slice is defined by an η\eta range of 0.05 in the short strip layer at 510 mm, and one of five vzv_z slices with boundaries at ±(40,140,500)\pm(40,140,500) mm, extrapolated to the other detector layers and with a small amount of padding added. There is thus substantial overlap between slices, and many roads are identified multiple times, hence fast overlap removal following the Hough Transform is important.

With this configuration, to cover the full detector in ϕ\phi and out to ∣η∣<0.9|\eta| < 0.9 requires 2880 accumulators. Figure 16 show ten example accumulator histograms for two ϕ\phi segments.

Image not extracted

Figure 16. Accumulators spanning 0.0<ϕ<0.80.0 < \phi< 0.8, for the zz slices defined by 0.05<η<0.100.05 < \eta< 0.10. Roads present in multiple accumulators are only removed if the ϕ\phi and η\eta of the accumulator is the same - i.e. between those arranged vertically here, with different zz-slicing - hence the same roads appear to be present in both sets (left and right).

In events averaging 16000 hits in this region (∣η∣<0.7|\eta|<0.7, extended +- 500mm in zz) in the relevant detector layers (covering strip, short strip and outer pix (barrel only for all)), each accumulator has on average around 300 hits thanks to overlaps between them (particularly in the z/z0z/z_0 slicing) – ie about 900k accumulator entries total.

This leads to around 650 (1500) bins per accumulator which are above the threshold of 6 (7) – a collection of hits known as a road. Having removed duplicate and subsets within accumulators (ie, those roads containing a set of hits completely contained in another road), this drops to around 210 (2000) roads per accumulator. After removing overlaps between accumulators of the same eta and phi coordinates but different zz slice, this becomes around 75 (500) roads per accumulator. Finally, removing overlaps between overlapping vzv_z slices leads to about 220,000 (400,000) roads per event, or 75 (140) per accumulator. The numbers of roads found by this procedure is thus highly dependent on the threshold adopted, which itself has a large impact on the track-finding efficiency.

Figure 17 shows the evolution of number of track candidates reconstructed and reconstruction efficiency for different accumulator thresholds.

Image not extracted

Figure 17. Hough Transform performance, considering true tracks within ∣η∣<0.7\lvert\eta\rvert< 0.7 and all ϕ\phi, for events containing 30 single muons (bottom) and ttˉt\bar{t} with 200 pileup events overlaid (top)

Image not extracted

Figure 18 (PDF p. 21).

Acknowledgments

This research was supported in part by the U.S. Department of Energy’s Office of Science, Office of High Energy Physics, under Contracts No. DE-SC0012704, (BNL Laboratory Directed Research and Development Investment LDRD 19-027 and Early Career grant LAB19-2019, FWP PO201) and DE-SC0011726; the National Science Foundation under Cooperative Agreement OAC-1836650. This work was supported by resources provided by the Scientific Data and Computing Center (SDCC), a component of the Computational Science Initiative (CSI) at Brookhaven National Laboratory (BNL). We would like to thank J. Adelman, E. Brost and S. Majewski for their help in designing the algorithm for duplicate removal and general discussion.

References

  1. [1]L. Evans and P. Bryant. LHC Machine. JINST,, 3:S08001, 2008.
  2. [2]G. Aad et al. The ATLAS Experiment at the CERN Large Hadron Collider. JINST, 3:S08003, 2008.
  3. [3]G. et al Apollinari. High-Luminosity Large Hadron Collider (HL-LHC): Technical Design Report V. 0.1. 4/2017, 2017.DOI
  4. [4]A. Abada. et al. FCC-hh: The Hadron Collider. The European Physical Journal Special Topics, 228, 2019.
  5. [5]Keiron O’Shea and Ryan Nash. An introduction to convolutional neural networks, 2015.arxiv.org/abs/1511.08458
  6. [6]Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks, 2012.
  7. [7]Aristeidis Tsaris et al. The HEP.TrkX project: Deep learning for particle tracking. Journal of Physics: Conference Series, 1085:042023, sep 2018.DOI
  8. [8]Xiangyang et al Ju. Graph neural networks for particle reconstruction in high energy physics detectors, 2020.arxiv.org/abs/2003.11603
  9. [9]Abdelrahman Elabd et al. Graph Neural Networks for Charged Particle Tracking on FPGAs. Front. Big Data, 5:828666, 2022.DOI
  10. [10]Gage DeZoort, Savannah Thais, Javier Duarte, Vesal Razavimaleki, Markus Atkinson, Isobel Ojalvo, Mark Neubauer, and Peter Elmer. Charged Particle Tracking via Edge-Classifying Interaction Networks. Comput. Softw. Big Sci., 5(1):26, 2021.DOI
  11. [11]Xiangyang Ju et al. Performance of a geometric deep learning pipeline for HL-LHC particle tracking. The European Physical Journal C, 81(10), oct 2021.DOI
  12. [12]ATLAS Collaboration. Performance of the ATLAS track reconstruction algorithms in dense environments in LHC run 2. The European Physical Journal C, 77(10), oct 2017.DOI
  13. [13]R Mankel. Pattern recognition and event reconstruction in particle physics experiments. Reports on Progress in Physics, 67(4):553–622, mar 2004.DOI
  14. [14]Min-Yu Huang, Shih-Chieh Wei, Bormin Huang, and Yang-Lang Chang. Accelerating the kalman filter on a gpu. In 2011 IEEE 17th International Conference on Parallel and Distributed Systems, pages 1016–1020, 2011.DOI
  15. [15]H. White K. Hornik, M. Stinchcombe. Multilayer feedforward networks are universal approximators. Neural Networks, 2:359–356, 1989.
  16. [16]Herbert Jaeger, Mantas Lukoševičius, Dan Popovici, and Udo Siewert. Optimization and applications of echo state networks with leaky-integrator neurons. Neural networks, 20(3):335–352, 2007.pubmed.ncbi.nlm.nih.gov/17517495
  17. [17]Richard O. Duda and Peter E. Hart. Use of the hough transformation to detect lines and curves in pictures. Commun. ACM, 15(1):11–15, jan 1972.
  18. [18]P. V. Hough. Method and means for recognizing complex patterns. US Patent 3,069,654, 1962.
  19. [19]ATLAS Collaboration. Technical design report for the phase-ii upgrade of the atlas trigger and data acquisition system - ef tracking amendment, 2022.DOI
  20. [20]Xiaocong et al. Ai. A common tracking software project, 2021.DOI
  21. [21]Corentin Allaire, Paul Gessinger, Julia Hdrinka, Moritz Kiehn, Fabian Kimpel, Joana Niermann, Andreas Salzburger, and Stanislava Sevova. Opendatadetector, April 2022.DOI
  22. [22]François Chollet et al. Keras. https://keras.io, 2015.
  23. [23]Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, Alban Desmaison, Andreas Kopf, Edward Yang, Zachary DeVito, Martin Raison, Alykhan Tejani, Sasank Chilamkurthy, Benoit Steiner, Lu Fang, Junjie Bai, and Soumith Chintala. Pytorch: An imperative style, high-performance deep learning library. In H. Wallach, H. Larochelle, A. Beygelzimer, F. d'Alché-Buc, E. Fox, and R. Garnett, editors, Advances in Neural Information Processing Systems 32, pages 8024–8035. Curran Associates, Inc., 2019.arxiv.org/abs/1912.01703
  24. [24]Farah Fahim et al. hls4ml: An open-source codesign workflow to empower scientific low-power machine learning devices. CoRR, abs/2103.05579, 2021.arxiv.org/abs/2103.05579

Paper details

vlnc:W_g9vyehka
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