1 Introduction
Traditionally, Machine Learning (ML) techniques are a key ingredient to event processing at particle colliders, employed in tasks such as particle reconstruction (clustering), identification (classification), and energy or direction measurement (regression) in calorimeters and tracking devices. The first applications of Neural Networks to High Energy Physics (HEP) date back to the ’80s
[1, 2, 3, 4]. Starting with the MiniBooNE experiment [5], Boosted Decision Trees became the state of the art, and played a crucial role in the discovery of the Higgs boson by the ATLAS and CMS experiments
[6]. Recently, a series of studies on different aspects of LHC data taking and data processing workflows have demonstrated the potential of Deep Learning (DL) in collider applications, both as a way to speed up current algorithms and to improve their performance. Nevertheless, the list of DL models actually deployed in the centralized workflows of the LHC experiments remains quite short.^{1}^{1}1As an example, at the moment such a list for the CMS experiment consists of a set of btagging algorithms
[7, 8] and a data quality monitoring algorithm for the muon drift tube chambers [9]. Other applications exist at the analysis level, downstream from the centralized event processing. In data analyses, one typically considers abstract fourmomenta and not the lowlevel quantities such as detector hits, making the use of DL techniques easier.Many of these studies, which are typically proofofconcept demonstrations, are based on convolutional neural networks (CNN)
[10], which perform computing vision tasks by applying translationinvariant kernels to
raw digital images. CNN architectures applied on HEP data thus imposes a requirement for the particle detectors to be represented as regular arrays of sensors. This requirement, common to many of the approaches described in Section 2, creates problems for realistic applications of CNNs in collider experiments.^{2}^{2}2The picture is completely different in other HEP domains. For instance, CNNs have been successfully deployed in neutrino experiments, where the regulararray assumption meets the geometry of a typical detector.In this work, we propose novel Deep Learning architectures based on graph networks to improve the performance and reduce the execution time of typical particlereconstruction tasks, such as cluster reconstruction and particle identification. In contrast to CNNs, graph networks can learn optimal detectorhits representations without making specific assumptions on the detector geometry. In particular, no preprocessing of data from detectors is required, even for detectors with irregular geometries. We consider the specific case of calorimeteric particle reconstruction, for which this characteristic of graph networks may become especially relevant in the near future. In view of the HighLuminosity LHC phase, the endcap calorimeter of the CMS detector will be replaced by a noveldesign digital calorimeter, the High Granularity Calorimeter (HGCAL), consisting of arrays of hexagonal silicon sensor cells interleaved with absorber layers [11]. Being positioned close to the beam pipe and exposed to protonproton collisions on average per bunch crossing, this detector will be characterized by high occupancy over its large number of readout channels. Downstream in the data processing pipeline, the unprecedented number of sensors and their geometry will cause an increase in event size and consequently the computational needs, necessitating novel data processing approaches given the expected computing limitations [12]. The detector we consider in this study, described in detail in Section 4, is loosely inspired by the HGCAL geometry. In particular, it features a similarly irregular sensor structure, with sensor sizes varying with the detector depth as well as within a single layer. On the other hand, the HGCAL hexagonal sensors were traded for squareshaped sensors, in order to keep the computing resources needed to generate the training data set within a manageable limit.
As a benchmark application, we consider the basis for all further particle reconstruction task in a calorimeter: clustering of the recorded energy deposits into disentangled showers from individual particles. To this purpose, we introduce two novel distanceweighted graph network architectures, the GarNet and the GravNet layers, which are designed to provide a good balance between performance and computing resources needs for inference. While our discussion is limited to a calorimetryrelated problem, the design of these new layer architectures is such that it automatically generalizes to any kind of sparse data, such as hits collected by a typical tracking device or reconstructed particle candidates inside a hadronic jet. We believe that architectures of this kind are more practical to deploy in a realistic experimental environment and could become relevant for the LHC experiments, both for offline and realtime event processing and selection.
This paper is structured as follows: Section 2 reviews related previous works. In Section 3, we describe the GravNet and GarNet architectures. Section 4 describes the data set used for this study. Section 5 introduces the metric used to optimize the networks. Section 6 describes the models. The results are presented in Sections 7 and 8 in terms of the accuracy and computational efficiency, respectively. Conclusions are presented in Section 9.
2 Related Work
In recent years, deep learning models, and in particular CNNs, have become very popular in different areas of HEP. CNNs were successfully applied to calorimeteroriented tasks, including particle identification [13, 14, 15, 11, 16], energy regression [13, 15, 11, 16], hadronic jet identification [17, 18, 19, 20], fast simulation [21, 22, 13, 23, 24] and pileup subtraction in jets [25]. Many of these works assume a simplified detector description: the detector is represented as a somehow regular array of sensors expressed as 2D or 3D images, and the problem of overlapping regions at the transition between detector components (e.g. barrel and endcap) is ignored. Sometimes the fixedgrid pixel shape is intended to reflect the typical angular resolution of the detector, which is implicitly assumed to be a constant, while in reality it depends on the energy of the incoming particle.
Overcoming the necessity for a regular structure motivated original research to use graphbased networks [26], which in general are suited for processing pointwise data with no regular structure by representing them as vertices in a graph. A comprehensive overview of various graphbased networks can be found in Ref. [27]. The connections between the vertices (edges) usually define paths of information exchange [28, 29]. In some cases, the edge and vertex properties are used to infer attention (weight) assigned to each neighbour during this information exchange [30], however, without changing the neighbour relations themselves. Particularly interesting for irregular detectors are networks that are capable of learning the geometry, as studied in combination with message passing [31]. Within this approach, the adjacency matrix is trainable. The idea has also been adopted in the context of jet identification [32]. Although this approach is promising, its downside is the need to connect all vertices with each other, which makes it unsuitable for graphs with a large number of vertices as the memory requirement becomes forbiddingly high. This problem is overcome by defining only a subset of connections between neighbours in a learnable space representation, where the edge properties of each vertex to a limited number of its neighbours are used to calculate a new feature representation per vertex, which is then passed to the next layer of similar structure [33]. This approach is implemented in the EdgeConv layer and the corresponding DGCNN model [33]. The neighbours are selected based on the new vertex features, which makes it particularly challenging to create a gradient for training with respect to the neighbour selection. The DGCNN model works around this issue by using the edge features themselves. However, due to the dynamic calculation of neighbour relations in highdimensional space, this network requires substantial computing resources, which would make its use for triggering purposes in collider detectors unfeasible.
3 The GravNet and GarNet layers
The neural network layers proposed in this study are designed to provide competitive performance on particle reconstruction tasks while dealing with data sparsity in an efficient way. These architectures aim to keep a trainable space representation at minimal computational costs. The layers receive as input a data set, consisting of a batch of examples, each represented by a set of detector hits, embedded in the data set through features. For instance, the features could include the Cartesian coordinates of a given sensor, its address (layer number, module number, etc.), the sensor time stamp, the recorded energy, etc.
A pictorial representation of the operations performed by the two layers is shown in Figure 1. For both architectures, the first step is to apply a dense^{3}^{3}3Here and in the following, dense layer refers to a learnable weightmatrix multiplication and bias vector addition with respect to the last feature dimension, with shared weights over all other dimensions. In this case, the weights and bias are applied to the vertex features and shared over the vertices . This can also be thought of as a 2D convolution with a kernel. neural network to each of the detector hits, deriving from the features two output arrays: the first array () is interpreted as a set of coordinates in some learned representation space (for the GravNet layer) or as the distance between the considered vertex and a set of aggregators (for the GarNet layer); the second array () is interpreted as a learned representation of the vertex features. At this point, a given input example of initial dimension is converted into a graph with vertices in the abstract space identified by . Each vertex is represented by the features, derived from the initial inputs. The projection from the
to this graph is linear, with trainable weights and bias vectors.
The main difference between the GravNet and the GarNet architectures is in the way the vertices are connected when building the graph. In the case of the GravNet layer, the Euclidean distances between pairs of vertices in the space are used to associate to each vertex its closest neighbors. In the case of the GarNet layer, the graph is built connecting each of the vertices to a set of aggregators. What is learned by , in this case, is the distance between the vertex and the aggregators.
Once the edges of the graph are built, each of the vertex (aggregator) of the GravNet (GarNet) layer collects the information associated with the features across its edges. This is done in three steps:

The quantities
(1) are computed for the feature of each of the vertices connected to a given vertex or aggregator , scaling the original value by a potential, function of the euclidean distance , giving the gravitational network GravNet its name. The potential function is introduced to enhance the contribution of closeby vertices. For this reason, has to be a decreasing function of . In this study, we use a Gaussian potential for the GravNet layer^{4}^{4}4A gravitational potential () has singularities at and therefore cannot be used, however the potential we are using has a similar qualitative effect of pulling together vertices. and an exponential potential for the GarNet layer.

The functions computed from all the edges associated to a vertex of aggregator are combined, generating a new feature of . For instance, we consider the average of the across the edges and their maximum. While the maximum was already used in similar architectures [33], the use of the mean function was particularly crucial in our case, to improve the convergence with respect to the neighbour selection.

Each adopted combination rule in the previous step generates a new set of features , which is concatenated to the original vector. This extended vector is transformed into a set of new vertex features, using a fully connected dense layer with activation. The concatenation is done for each initial vertex. In the case of the GarNet layer, this requires an additional step of passing the features of the aggregators back to the initial vertices, weighted by the potential. This information exchange of the garnered information through the aggregators defines the GarNet name.
The full process transforms the initial data set into a data set. As common with graph networks, the main advantage comes from the fact that the output (unlike the input) carries collective information from each vertex and its surrounding, providing a more informative input to downstream processing. Thanks to the distinction between learned space information and learned features , the dimensionality of connections in the graph is kept under control, resulting in a smaller memory consumption than, for instance, the EdgeConv layer.
The two layer architectures and the models based on them, described in the following sections, are implemented in TensorFlow
[36]. The code for the models and layers can be found in https://github.com/jkiesele/caloGraphNN.4 Data set
The data set used in this paper is based on a simplified calorimeter with irregular geometry, built in GEANT4 [37]. The calorimeter has a width of in the x and y directions and length of 2 in the longitudinal direction (z), corresponding to 20 nuclear interaction lengths. It is entirely made out of Tungsten, further split into 20 layers of equal width in z. Each layer contains square sensor cells, with a fine segmentation in the quadrant with and and a lower granularity elsewhere. The total number of cells and their individual sizes vary by layer, replicating the basic features of a slightly irregular calorimeter. For more details, see Figure 2 and Table 1.
Layer  Cells (, )  Cells elsewhere 

0  64  48 
1  64  108 
2–3  100  192 
4–7  64  108 
8–11  64  48 
12–13  16  12 
14–19  4  3 
Charged pions are generated at ; the and coordinates of the generation vertex are randomly sampled within and . The and components of the particle momentum are set to 0, while the component is sampled uniformly between 10 and 100. The particles therefore impinge the calorimeter front face perpendicularly and shower along the longitudinal direction.
The resulting total energy deposit in each cell, as well as the cell position, width, and layer number, are recorded for each event. These quantities correspond to the feature vector given as input to the graph models (see Section 3). Each example consists of the result of two overlapping showers. Cell by cell, the energy of two showers is summed and the fraction belonging to each of the showers in each cell is defined as the ground truth. In addition, the position of the largest energy deposit per shower is recorded. If this position is the same for the two overlapping showers, they are considered not separable and the event is discarded. This applies to about 5% of the events.
In total 16000000 events are generated. Out of these, 100000 are used for validation and 20000 for testing. The rest is used for training.
5 Clustering metrics
To identify individual showers and use their properties, e.g. for a subsequent particle identification task, the energy deposits should be clustered so that overlapping parts are identified without removing important parts of the original shower. Therefore, the clustering algorithms should predict the energy fraction of each sensor belonging to each shower. Lower energy deposits are slightly less important. These considerations define the loss function:
(2) 
where and are the predicted and true energy fractions in sensor and shower . These are weighted by the square root of , which is the total energy deposit in sensor belonging to shower , to introduce a mild energy scaling within each shower. In addition, we define the clustering energy response for one test shower as:
(3) 
6 Models
The models need to incorporate neural network layers to identify localized structures as well as to perform information exchange globally between the sensors. This can be achieved either by multiple message passing iterations between neighbouring sensors or a direct global information exchange. Here, we employ a combination of both. The input to all models is an array of sensors, each holding its recorded energy deposits, global position coordinates, sensor size, and layer number. We compare three different graphnetwork approaches to a CNN based approach (Binning), presented as a baseline. Each model is designed to contain approximately free parameters. The model structure is as follows:

Binning: a regular grid of pixels is imposed on the irregular geometry. Each pixel contains the information of at most one sensor^{5}^{5}5Alternative configurations with more than one sensor per pixel were also investigated and showed similar performance.. The information is concatenated to the mean of these features in all pixels, preprocessed by one CNN layer with 20 nodes, and then fed through eight blocks of CNN layers. Each block consists of a CNN layer with a kernel of followed by a layer with a kernel of
, each containing 14 filters. The output of each block is passed to the next block as well as it is added to a list of all block outputs. All CNN layers employ tanh activation functions. Finally, the full list of block outputs per pixel is reshaped to represent the vertices of the graph and fed through a dense layer with 128 nodes and ReLU activation. Different CNN models have also been tested and showed similar or worse performance.

DGCNN model: adapting the model proposed in Ref [33] to our problem, the sensor features are interpreted as positions of points in a 16dimensional space and fed through one global space transformation followed by four blocks comprising one EdgeConv layer. Our EdgeConv layer has a similar configuration as in Ref. [33], with 40 neighbouring vertices and three internal dense layers with ReLu activation acting on the edges with 64 nodes each. The output of the EdgeConv layer is concatenated with its mean over all vertices and fed to one dense layer with 64 nodes and ReLu activation which concludes the block. The output of each block is passed to the next block and simultaneously added to a list of all block outputs per vertex, which is finally fed to a dense layer with 32 nodes and ReLU activation.

GravNet model: the model consists of four blocks. Each block starts with concatenating the mean of the vertex features to the vertex features, three dense layers with 64 nodes and activation, and one GravNet layer with coordinate dimensions, features to propagate, and output nodes per vertex. For each vertex, 40 neighbours are considered. The output of each block is input to the next block and added to a list containing the output of all blocks. This determines the full vector of vertex features passed to a final dense layer with 128 nodes and ReLU activation.

GarNet model: The original vertex features are concatenated with the mean of the vertex features and then passed on to one dense layer with 32 nodes and tanh activation before entering 11 subsequent GarNet layers. These layers contain aggregators, to which features are passed, and output nodes. The output of each layer is passed to the next and in addition added to a vector containing the concatenated outputs of each GarNet layer. The latter is finally passed to a dense layer with 48 nodes and ReLU activation.
In all cases, each output vertex of these model building blocks is fed through one dense layer with ReLU activation and three nodes, followed by a dense layer with two output nodes and softmax activation. This last processing step determines the energy fraction belonging to each shower. Batch normalisation [38] is applied in all models to the input and after each block.
All models are trained on the full training data set using the Adam optimizer [39] and an initial learning rate of about , depending on the model. The learning rate is reduced exponentially in steps to the minimum of after 2 million iterations. Once the learning rate has reached the minimum level, it is modulated by 10% at a fixed frequency, following the method proposed in Ref. [40].
7 Clustering performance
All approaches described in Section 6 perform well for clustering purposes. An example is shown in Figure 3, where two charged pions with approximately 50 initial energy enter the calorimeter. One pion loses a significant fraction of energy in an electromagnetic shower in the first calorimeter layers. The remaining energy is carried by a single particle passing the central part of the calorimeter before showering. The second pion passes the first layers as a minimally ionizing particle and showers in the central part of the calorimeter. Even though the two showers largely overlap, the GravNet network (shown here as an example) is able to identify and separate the two showers very well. The track within the calorimeter is well identified and reconstructed and the energy fractions properly assigned, even in the parts where the two showers heavily overlap. Similar performance can be observed with the other investigated methods.
Quantitatively, the performance of the models is compared using the mean loss () on the test data set, as well as the clustering response as defined in Equations 2 and 3. For every event, we define one of the shower as the test shower and the other overlapping shower as noise shower. Performance characteristics are evaluated only for the test shower and are quantified by the mean (
) and variance (
) of the response in the test data set. In addition, we define clustering accuracy () as the fraction of showers with response between 0.7 and 1.3. Given that some showers are not properly clustered, the response distribution has a small fraction of outliers that disturb its otherwise rather Gaussian shape. Therefore, test showers with response less than 0.2 and higher than 2.8 are removed, resulting in the response kernel mean
and variance .As listed in Table 2, the GravNet layer outperforms the other approaches, including even the more resourceintensive DGCNN model. The GarNet model is slightly worse than the DGCNN model but still outperforms the binning approach as far as the reconstruction of individual shower hit fractions is concerned, represented by the loss function. However, with respect to the clustering response, the binning model outperforms the GarNet and DGCNN model slightly.
Binning  0.192  0.017  1.085  0.187  1.046  0.058  0.867 

DGCNN  0.174  0.012  1.084  0.203  1.045  0.052  0.880 
GarNet  0.183  0.011  1.089  0.201  1.048  0.056  0.869 
GravNet  0.172  0.012  1.079  0.187  1.042  0.049  0.884 
One should notice that part of the incorrectly predicted events are actually correctly clustered events in which the test shower is labelled as noise shower (shower swapping). Since the labelling is irrelevant in a clustering problem, this behavior is not a real inefficiency of the algorithm. We denote by the fraction of events where this behaviour is observed. In Table 3, we calculate the loss for both choices and evaluate the performance parameters for the assignment that minimises the loss. The binning model shows the largest fraction of swapped showers. The difference in response between the bestperforming GravNet model and the GarNet model is enhanced, while the difference between the GravNet and DGCNN model scales similarly, likely because of their similar general structure.
Binning  0.180  0.007  1.078  0.150  1.048  0.055  0.875  3.2 

DGCNN  0.167  0.006  1.077  0.146  1.047  0.051  0.885  2.5 
GarNet  0.176  0.006  1.084  0.168  1.049  0.055  0.874  2.4 
GravNet  0.165  0.006  1.072  0.133  1.043  0.048  0.891  2.7 
As shown in Figure 4, the reconstructed energy for the test shower is biased towards low values for all models, indicating that on average lower energy showers obtain a fraction of the energy belonging to the higher energy shower. While this behaviour could be corrected a posteriori when the particle energy is measured, the variance of the response can only be corrected on an eventbyevent basis and is therefore the more important metric. In both metrics, the GravNet model outperforms the other models in the full range, and the GarNet model shows the worst performance, albeit in a comparable range. The resourceintensive DGCNN model lies in between GravNet and GarNet.
8 Resource requirements
In addition to the clustering performance, it is important to take into account the computational resources demanded by each model during inference. The inference time can have a significant impact on the applicability of the network for reconstruction tasks, in particular for the kind of realtime processing performed by the trigger systems of typical collider experiments. We evaluate the inference time and memory consumption for the models studied here on one NVIDIA GTX 1080 Ti GPU for batch sizes of 1 and 100, denoted as () and (, ), respectively. The inference time is also evaluated on one Intel Xeon E52650 CPU core () for a fixed batch size of 10. As shown in Figure 5, memory consumption and execution times differ significantly between the models. The binning approach outperforms all other models, because of the highly optimised CNN implementations. The DGCNN model requires the largest amount of memory, while the model using the GravNet layers requires about 50% less. The GarNet model provides the best compromise of memory consumption with respect to performance. In terms of inference time, the binning model is the fastest and the graphbased models show a similar behaviour for small batch sizes on a GPU. The GarNet and the GravNet model benefit from parallelizing over a larger batch. In particular, the GarNet model is mostly sequential, which also explains the outstanding performance on a single CPU core, with almost a factor of 10 shorter inference time compared to the DGCNN model.
9 Conclusions
In this work, we introduced the GarNet and GravNet layers, which are distanceweighted graph networks capable of learning irregular patterns of sparse data, such as the detector hits in a particle physics detector with realistic geometry. Using as a benchmark problem the hit clustering in a highly granular calorimeter, we show how these network architectures offer a good compromise between clustering performance and computational resource needs, when compared to CNNbased and other graphbased networks. In the specific case considered here, the performance of the GarNet and GravNet models are comparable to the CNN and graph baselines. On the other hand, the simulated calorimeter in the benchmark study is only slightly irregular and can still be represented by an almost regular array. In more realistic applications, e.g. with the hexagonal sensors and the nonprojective geometry of the future HGCAL detector of CMS, the difference in performance between the graphbased approaches and the CNNbased approaches is expected to increase further, making the GarNet approach a very efficient candidate for fast and accurate inference and the GravNet approach a good candidate for highperformance reconstruction with less resource requirements and better performance than the DGCNN model.
It should also be noted that the GarNet and GravNet architectures make no specific assumption on the structure of the underlying data, and thus can be employed for many other applications related to particle and event reconstruction, such as tracking and jet identification. Exploring the extent of usability of these architectures will be the focus of followup work.
We thank our CMS colleagues for many suggestions received in the development of this work. The training of the models was performed on the GPU clusters of the CERN TechLab and the CERN CMG group. This project has received funding from the European Research Council (ERC) under the European Union’s Horizon 2020 research and innovation program (grant agreement n 772369).
References
 [1] B. H. Denby, Neural Networks and Cellular Automata in Experimental Highenergy Physics, Comput. Phys. Commun. 49 (1988) 429–448.
 [2] C. Peterson, Track Finding With Neural Networks, Nucl. Instrum. Meth. A279 (1989) 537.
 [3] DELPHI collaboration, P. Abreu et al., Classification of the hadronic decays of the Z0 into b and c quark pairs using a neural network, Phys. Lett. B295 (1992) 383–395.
 [4] B. H. Denby, Neural networks in highenergy physics: A ten year perspective, Comput. Phys. Commun. 119 (1999) 219–231.
 [5] H.J. Yang, B. P. Roe and J. Zhu, Studies of boosted decision trees for miniboone particle identification, Nuclear Instruments and Methods in Physics Research Section A: Accelerators, Spectrometers, Detectors and Associated Equipment 555 (2005) 370 – 385.
 [6] A. Radovic et al., Machine learning at the energy and intensity frontiers of particle physics, Nature 560 (2018) 41–48.
 [7] CMS collaboration, CMS Phase 1 heavy flavour identification performance and developments, Tech. Rep. CMSDP2017013, May, 2017.
 [8] CMS collaboration, New Developments for Jet Substructure Reconstruction in CMS, Tech. Rep. CMSDP2017027, Jul, 2017.
 [9] A. A. Pol et al., Detector monitoring with artificial neural networks at the CMS experiment at the CERN Large Hadron Collider, Comput. Softw. Big Sci. 3 (2019) 3, [1808.00911].
 [10] A. Krizhevsky, I. Sutskever and G. E. Hinton, Imagenet classification with deep convolutional neural networks, in Advances in neural information processing systems, pp. 1097–1105, 2012.
 [11] CMS Collaboration, The Phase2 Upgrade of the CMS Endcap Calorimeter, Tech. Rep. CERNLHCC2017023. CMSTDR019, CERN, Geneva, Nov, 2017.
 [12] CMS collaboration, V. Khachatryan et al., Technical Proposal for the PhaseII Upgrade of the CMS Detector, Tech. Rep. CERNLHCC2015010. LHCCP008. CMSTDR1502, Jun, 2015.
 [13] F. Carminati et al., Calorimetry with deep learning: particle classification, energy regression, and simulation for highenergy physics, 2017.
 [14] D. Guest, K. Cranmer and D. Whiteson, Deep Learning and its Application to LHC Physics, Ann. Rev. Nucl. Part. Sci. 68 (2018) 161–181, [1806.11484].
 [15] L. De Oliveira, B. Nachman and M. Paganini, Electromagnetic Showers Beyond Shower Shapes, 1806.05667.
 [16] M. Benedikt et al., Future Circular Collider, Tech. Rep. CERNACC20180058, CERN, Geneva, Dec, 2018.
 [17] J. Cogan, M. Kagan, E. Strauss and A. Schwarztman, JetImages: Computer Vision Inspired Techniques for Jet Tagging, JHEP 02 (2015) 118, [1407.5675].
 [18] P. T. Komiske, E. M. Metodiev and M. D. Schwartz, Deep learning in color: towards automated quark/gluon jet discrimination, JHEP 01 (2017) 110, [1612.01551].
 [19] L. de Oliveira et al., Jetimages – deep learning edition, JHEP 07 (2016) 069, [1511.05190].
 [20] P. Baldi, K. Bauer, C. Eng, P. Sadowski and D. Whiteson, Jet Substructure Classification in HighEnergy Physics with Deep Neural Networks, Phys. Rev. D93 (2016) 094034, [1603.09349].
 [21] L. de Oliveira, M. Paganini and B. Nachman, Learning Particle Physics by Example: LocationAware Generative Adversarial Networks for Physics Synthesis, Comput. Softw. Big Sci. 1 (2017) 4, [1701.05927].
 [22] M. Paganini, L. de Oliveira and B. Nachman, CaloGAN : Simulating 3D high energy particle showers in multilayer electromagnetic calorimeters with generative adversarial networks, Phys. Rev. D97 (2018) 014021, [1712.10321].
 [23] G. Rukhkhattak, S. Vallecorsa and F. Carminati, Three dimensional energy parametrized generative adversarial networks for electromagnetic shower simulation, in 2018 25th IEEE International Conference on Image Processing (ICIP), pp. 3913–3917, IEEE, 2018.
 [24] P. Musella and F. Pandolfi, Fast and Accurate Simulation of Particle Detectors Using Generative Adversarial Networks, Comput. Softw. Big Sci. 2 (2018) 8, [1805.00850].
 [25] P. T. Komiske, E. M. Metodiev, B. Nachman and M. D. Schwartz, Pileup Mitigation with Machine Learning (PUMML), JHEP 12 (2017) 051, [1707.08600].
 [26] F. Scarselli, M. Gori, A. C. Tsoi, M. Hagenbuchner and G. Monfardini, The graph neural network model, IEEE Transactions on Neural Networks 20 (2009) 61–80.
 [27] P. W. Battaglia, J. B. Hamrick, V. Bapst, A. SanchezGonzalez, V. Zambaldi, M. Malinowski et al., Relational inductive biases, deep learning, and graph networks, arXiv preprint arXiv:1806.01261 (2018) .
 [28] M. Defferrard, X. Bresson and P. Vandergheynst, Convolutional neural networks on graphs with fast localized spectral filtering, in Advances in Neural Information Processing Systems, pp. 3844–3852, 2016.
 [29] P. Velickovic, G. Cucurull, A. Casanova, A. Romero, P. Lio and Y. Bengio, Graph attention networks, arXiv preprint arXiv:1710.10903 1 (2017) .

[30]
C. Selvi and E. Sivasankar,
A novel adaptive genetic neural network (agnn) model for recommender systems using modified kmeans clustering approach
, Multimedia Tools and Applications (Nov, 2018) .  [31] J. Gilmer, S. S. Schoenholz, P. F. Riley, O. Vinyals and G. E. Dahl, Neural message passing for quantum chemistry, arXiv preprint arXiv:1704.01212 (2017) .
 [32] I. Henrion et al., Neural message passing for jet physics, 2017.
 [33] Y. Wang, Y. Sun, Z. Liu, S. E. Sarma, M. M. Bronstein and J. M. Solomon, Dynamic graph cnn for learning on point clouds, arXiv preprint arXiv:1801.07829 (2018) .
 [34] M. Abdughani, J. Ren, L. Wu and J. M. Yang, Probing stop with graph neural network at the LHC, 1807.09088.
 [35] J. Arjona Martinez, O. Cerri, M. Pierini, M. Spiropulu and J.R. Vlimant, Pileup mitigation at the Large Hadron Collider with Graph Neural Networks, 1810.07988.
 [36] M. Abadi et al., TensorFlow: Largescale machine learning on heterogeneous systems, 2015.
 [37] GEANT4 collaboration, S. Agostinelli et al., GEANT4: A Simulation toolkit, Nucl. Instrum. Meth. A506 (2003) 250–303.
 [38] S. Ioffe and C. Szegedy, Batch normalization: Accelerating deep network training by reducing internal covariate shift, CoRR abs/1502.03167 (2015) , [1502.03167].
 [39] D. P. Kingma and J. Ba, Adam: A method for stochastic optimization, CoRR abs/1412.6980 (2014) , [1412.6980].
 [40] L. N. Smith and N. Topin, Superconvergence: Very fast training of residual networks using large learning rates, CoRR abs/1708.07120 (2017) , [1708.07120].
Comments
There are no comments yet.