Particle tracking is a very important part of modern high energy physics experiments. While the data stream from such experiments is increasing day by day, classic tracking methods lack the ability to fit these amounts of data. In order to solve this problem, new effective machine learning algorithms are actively developed in the HEP.TrkX project for Large Hadron Collider detector and for the GEM detector of the BM@N experiment. This work is a logical continuation of the research presented on the XXIII International Scientific Conference of Young Scientists and Specialists (AYSS-2019), where we have already introduced a new application for tracking with the Graph Neural Network based on the Minimum Branching Tree preprocessing. However, that approach has had some problems, including the overall inaccuracy with the segments purification of the preprocessed event graph. In this work, we overcome many of such problems and introduce a revised approach with improved tracking accuracy. Promising results of the improved GNN tracking are given.
Modern high energy and nuclear physics (HENP) requires precise and effective reconstruction of events occurring during its experiments. One of the most important parts of event reconstruction is tracking of the particle trajectories (tracks). This process called particle tracking or just tracking, and it demands swiftest and most accurate algorithms to operate on, as in the modern experiments beams of heavy ions are collided on the very high speeds, and particle collisions produce enormous amounts of traces of the secondary particles in the sensitive elements of tracking detectors. These traces are to be converted then into so-called ‘hits’, which is usually points in some coordinate space, and one of the main parts of the event reconstruction process is to search for groups of those hits each connected by affiliation to the same track.
As we are working on the BM@N experiment of the NICA megaproject [
At the same time, machine learning approaches have the capability of modeling such complex
environments and can be effectively run in parallel. There are some existing machine learning
approaches for tracking [
Recently the idea of graph representation in machine learning found great success with the
Geometric Deep Learning methods known as Graph Neural Networks (GNN) [4], and the recent
HEP.TrkX approach [
The key idea of our approach is an event-as-a-graph representation when registered hits are nodes of the graph and edges of the graph fully connect the nodes between the adjacent layers of the detector. One can see the full graph of a particular event simulated for the GEM BM@N in figure 1.
GNN consumes the nodes’ features, namely, 3-D coordinates (X, Y, Z) of the hit and their
connectedness of each other and the adjacency matrix of nodes (hits). The forward pass of the model
consists of iterating data through the 2 subnetworks, so-called ‘Edge’ and ‘Node’ networks. The Edge
network selects nodes’ features and the Node network aggregates neighbor node features. The full
details and explanation of the model one can find at [
During the integration of this approach for the GEM data we recognized the biggest pitfall of the initial approach – while it works on the data without the fake hits perfectly, it is highly afflicted by the great fake count, which is a common problem of the microstrip-based detectors like GEM. This approach cannot handle huge noise rate and for that purpose, we had to introduce a special filtering process containing two main steps: ● Truncating the segments based on their statistical behavior (i.e. cutting all segments which angle exceeds some constant). This step brings substantial influence on the overall noise rate, reducing the noise factor by half. ● Utilizing the Minimum Branching Tree. It brings a huge impact on the overall fake segment rate. We discovered that MBT-based filtering reduces the fake-to-real ratio from 1:120 to 1:10 (for one true segment we observe 10 fake segments). But this algorithm has one big disadvantage – it discards about 18% of true segments.
After applying the filtering described above, GNN showed promising results achieving 77% recall and 96% precision on the preprocessed data. This result has inspired us towards the continuation of our studies, so we needed to improve the filtering process and increase the overall network accuracy.
The common straightforward method for improving neural network model accuracy is to feed the network with more features. As it was mentioned above, the GNN model uses a hits 3-D coordinate position as a feature. Looking at the physical interpretation of particle track one can notice that track in the GEM detector is usually a smooth curve that has a concavity, which is not varying much, being approximately constant. In other words, the track curve has about the same value for its first-order derivative (and always the same sign). The information of the curve monotonicity and concavity can be obtained as the gradient of particle track function and its Laplacian, correspondingly. We would like to use such characteristics as features and feed it to the network. But the network consumes only the hits positional information as nodes features. The information about the segment direction (‘monotonicity’) can be obtained only if we use it as an edge feature (because segment direction depends on the two nodes positions, which cannot be encoded into a single node). Unfortunately, current GNN architecture utilizes the graph adjacency matrix as a binary mask for the network message passing mechanism so it is considerably hard to encode such information to the current event-as-a-graph representation. Therefore, we found a new type of graph representation that is more in line with our intentions.
Line graph [
Roughly speaking, the line graph inverts the nodes and edges of the original graph. We also can use the directed version of line graph, called ‘line digraph’. If is a directed graph, its directed line graph or line digraph has one vertex for each edge of . Two vertices representing directed edges from to and from to in are connected by an edge from to in the line digraph when = . That is, each edge in the line digraph ( ) represents a length-two directed path in G. The biggest advantage of such transformation is the fact that edge features from the initial graph turn into node features of the line graph which becomes really convenient to use within the GNN model.
Consider the initial event-as-a-graph conception we are transforming the initial graph to the line digraph ( ). As an initial graph fully-connects adjacent layers nodes we can apply the same approach described above: each (graph) path of two consecutive segments will be the edge of ( ); each segment will be the node of the new line digraph ( ). In this situation, each node of ( ) gathers two 3-D coordinate positions from the two initial event hits. One can see the resulting line digraph representing the same event as in figure 1 is depicted in figure 2 where almost all tracks become more straighten in such representation because they are in fact first-order derivatives of initial tracks.
Despite the fact that this representation brought new features ( and values) to the network model, it still suffers from a big amount of fake segments. But now filtering fake segments is a much simpler procedure: the segment of a line digraph now, in fact, represents hits from three consecutive layers, so we can compute the second-order derivative of a curve which passes through these hits. So, the current filtering process is the following: ● construct line digraph; ● compute edges weight; edge weight computed as = ( 2 , 2 ), where 2 is computed as 2 = 1 − 0 = ( 2 − 1) − ( 1 − 0) = 2 − 2 ∗ 1 − 0. 2, 1, and 0 are three consecutive hits’ coordinates of a track curve. ● filter out all segments with weight value more than a constant.
This filtering process achieves 100% purity (purity is the count of true segments left after filtering divided by the count of initial true segments) and reduces overall fake segment rate up to 10 times (fake segment rate is the count of fake segments divided by the count of true segments). It is worth to note that constructing line digraph, finding and filtering segments can be computed with up to ( ) operations with usage up to ( 2) memory, where is a number of segments in the graph. We also vectorized this algorithm and achieved the resulting speed about ~7 events/sec; which is, in fact, satisfying for the current study but an important thing to improve in the future.
We used the same network architecture and structure described in [6] except feeding it with segments produced by the filtered line digraph. During the network training, we observed that optimal feature configuration is a vector of the following five line digraph node features: ( 0, 1, 0, 1, ). With this configuration, our model achieves 85% precision and 96% recall on the validation dataset containing 4k events.
Moreover, we also have measured more strict metrics introduced in [
In this paper, we have introduced a novel approach for the effective graph representation of the event in GEM detector – line digraph. It facilitated both filtering and feature extraction processes. GNN being trained on line digraph achieves significant results even with the strict metrics reaching 94 % hit accuracy and 87% track accuracy and handles tracks of any length. The main drawback of the line digraphs is high memory consumption (because it is quadratic from the total hit count in the event). Now we are going to speedup the filtering process; embed line graph architecture into the network model itself; overcome memory issues; expand the approach to solve tracking in a collider environment.
The reported study was funded by RFBR, project number 18-02-40101.