PaperlayerView exact revision on arXiv

Source-linked AI summary

ParticleNet: Jet Tagging via Particle Clouds

Huilin Qu, Loukas Gouskos

arXiv:1902.08570v3hep-phcs.CVhep-ex

TL;DR

Jet tagging depends on representing constituent particles without imposing an artificial ordering. The paper models jets as particle clouds and introduces ParticleNet, a DGCNN-based architecture; it reports state-of-the-art performance on top-tagging and quark-gluon-tagging benchmarks.

  • Problem

    Jet representations must incorporate reconstructed-particle information while handling particle sets whose constituents have no intrinsic order and whose image encodings can be sparse and inefficient.

  • Method

    ParticleNet treats each jet as an unordered particle cloud and applies a customized Dynamic Graph Convolutional Neural Network for jet tagging.

  • Results

    ParticleNet achieves state-of-the-art performance on both top-tagging and quark-gluon-tagging benchmarks, significantly improving over existing methods.

  • Takeaways & Limitations

    Particle-cloud representations support flexible per-particle information while ParticleNet exploits local neighborhood structure for jet tagging.

Abstract

from arXiv · show

How to represent a jet is at the core of machine learning on jet physics. Inspired by the notion of point clouds, we propose a new approach that considers a jet as an unordered set of its constituent particles, effectively a "particle cloud". Such a particle cloud representation of jets is efficient in incorporating raw information of jets and also explicitly respects the permutation symmetry. Based on the particle cloud representation, we propose ParticleNet, a customized neural network architecture using Dynamic Graph Convolutional Neural Network for jet tagging problems. The ParticleNet architecture achieves state-of-the-art performance on two representative jet tagging benchmarks and is improved significantly over existing methods.

I. INTRODUCTION

Jet tagging identifies the elementary particle initiating a jet from properties of its reconstructed constituents. ParticleNet addresses this task by representing jets as unordered particle clouds and applying a customized graph-based network.

  • Jets are collimated sprays of particles produced in proton-proton collisions at the LHC.
  • Jet tagging identifies the elementary particle initiating a jet, whose characteristics can reveal the collision process.
  • Machine-learning methods have represented jets as images, sequences, trees, graphs, or particle sets for tagging.
  • ParticleNet treats constituent particles as an unordered set, analogous to a point cloud, and operates directly on this particle-cloud representation.
  • The paper evaluates ParticleNet on two jet-tagging benchmarks and reports significant improvements over existing methods.

A. Image-based representation

Jet images provide a studied representation for tagging, but reconstructed-particle inputs expose limitations in incorporating particle features and computational efficiency. Particle collections are more flexible and compact, while sequence and tree representations impose an artificial ordering.

  • Image representation: Calorimeter energy deposits naturally form jet images, while particle-flow jets can be mapped onto calorimeter cells.
  • Image representation: Image-based CNNs have achieved sizable improvements over traditional QCD-motivated multivariate methods on several tagging tasks.
  • Image representation: More than 90% of typical 32 × 32 jet-image pixels are blank because jets contain O(10) to O(100) particles, making image CNNs computationally inefficient.
  • Particle-based representation: Particle collections can include arbitrary per-particle features and are more compact than images, but their lengths vary across jets.
  • Particle-based representation: Sequences and binary trees organize particles using imposed orderings, supporting RNNs, 1D CNNs, physics-oriented networks, or recursive networks.
  • Particle-based representation: Because jet constituents have no intrinsic order, manually imposed ordering may be suboptimal and impair performance.

C. Jet as a particle cloud

The particle-cloud representation models a jet as an unordered, permutation-invariant set of correlated particles. ParticleNet uses a carefully designed DGCNN-based architecture to exploit this representation for jet tagging.

  • A particle cloud is an unordered, permutation-invariant set of a jet’s constituent particles.
  • Particle clouds retain flexible per-particle features while representing jets as irregularly distributed, internally correlated entities.
  • The representation is analogous to 3D point clouds, allowing point-cloud deep-learning algorithms to inform jet models.
  • Deep Sets processes particle clouds globally, whereas the DGCNN approach used here explicitly exploits local spatial structure.
  • ParticleNet is a CNN-like deep neural network designed for jet tagging with particle-cloud data.

A. Edge convolution

EdgeConv adapts convolution to irregular point clouds by defining local neighborhoods through nearest-neighbor graphs while preserving permutation symmetry. Its stackability enables hierarchical features and dynamically learned point proximity.

  • CNN success reflects shared kernels that exploit symmetry and hierarchical feature learning across scales.
  • Regular convolution cannot directly handle irregular point clouds because their local patches and permutation-invariant operation are not naturally defined.
  • EdgeConv constructs a graph by connecting each point to its k nearest neighbors, defining a local convolutional patch.
  • Shared edge-function parameters and symmetric aggregation make EdgeConv permutation-symmetric.
  • The paper uses neighbor-feature differences, a shared MLP edge function, and mean aggregation in its specialized EdgeConv form.
  • EdgeConv outputs another point cloud with the same number of points, allowing operations to stack and learn hierarchical features.
  • DGCNN recomputes nearest-neighbor proximity in a learned latent space, allowing the graph structure to change dynamically.

B. ParticleNet

ParticleNet adapts EdgeConv and dynamic graphs to particle-cloud jet data, while ParticleNet-Lite reduces complexity for resource-limited settings.

  • ParticleNet: ParticleNet uses customized EdgeConv blocks and dynamic graph updates to suit jet tagging.Its design choices include the neighbor count, EdgeConv MLP configuration, and shortcut connections.
  • ParticleNet: Each EdgeConv block finds k nearest particles from coordinates, constructs edge features, and processes them with a three-layer MLP.The layers apply linear transformations, batch normalization, and rectified linear units.
  • ParticleNet: ParticleNet stacks three EdgeConv blocks, using pseudorapidity-azimuth coordinates first and learned feature vectors thereafter.The blocks use k = 16 and channel configurations (64, 64, 64), (128, 128, 128), and (256, 256, 256), followed by global average pooling.
  • ParticleNet-Lite: ParticleNet-Lite uses two smaller EdgeConv blocks and reduces arithmetic operations by almost an order of magnitude.It is designed to be more suitable when computational resources are limited.
  • Training: The networks are implemented in Apache MXNet and trained with AdamW, cross-entropy loss, and a one-cycle learning-rate schedule.ParticleNet and ParticleNet-Lite use different batch sizes and learning-rate settings because of their differing resource requirements.

IV. RESULTS

ParticleNet is evaluated on two representative jet-tagging tasks: top tagging and quark-gluon tagging.

  • IV. RESULTS: ParticleNet is evaluated on top tagging and quark-gluon tagging benchmark tasks.The section presents benchmark results for both tasks.

A. Top tagging

The top-tagging study benchmarks ParticleNet against image-, sequence-, and set-based models using simulated jets and several classification metrics. ParticleNet achieves substantially stronger background rejection than the alternatives.

  • Dataset and task: Top tagging identifies jets originating from hadronically decaying top quarks and is commonly used in searches for new physics at the LHC.The benchmark uses a dataset generated with Pythia8 and processed through Delphes.
  • Dataset and task: The simulated top-tagging jets exclude multiple parton interactions and pileup and are restricted to pT ∈[550, 650] and |η| < 2.Signal jets are matched to hadronically decaying top quarks and their three decay quarks within ∆R = 0.8 of the jet axis.
  • Inputs: ParticleNet uses up to 100 highest-pT constituents and seven variables derived from each particle’s four-momentum.The (∆η, ∆φ) variables provide coordinates for distances in the first EdgeConv block.
  • Baselines: The comparison includes ResNeXt-50 image inputs, P-CNN particle sequences, and PFN unordered particle sets.PFN uses global symmetric functions but does not explicitly exploit local neighborhood information as EdgeConv does.
  • Metrics: The evaluation reports accuracy, AUC, and background rejection 1/εb at signal efficiencies of 50% and 30%.Background rejection is emphasized because it is directly related to expected background contributions in LHC analyses.
  • Results: 1.8 (2.1) times as good as PFN (P-CNN), and about 40% better than ResNeXt-50, ParticleNet’s background rejection is strongest at 30% signal efficiency.ParticleNet-Lite also outperforms all previous models, improving about 10% over ResNeXt-50.

B. Quark-gluon tagging

The quark-gluon study tests ParticleNet with kinematic and particle-identification inputs against several alternative models. ParticleNet performs best, and PID improves background rejection substantially.

  • Dataset and task: Quark-gluon tagging discriminates jets initiated by quarks from those initiated by gluons using a simulated dataset without detector simulation.The signal and background samples are generated with Pythia8 from Z(→νν) + (u, d, s) and Z(→νν) + g processes.
  • Inputs: The dataset includes particle types in addition to four-momentum, enabling ParticleNet variants with and without particle-identification inputs.PID is incorporated in an experimentally realistic way using only five particle-type categories.
  • Comparison: Table III compares ParticleNet, ParticleNet-Lite, P-CNN, and ResNeXt-50, including model variants with and without PID.ResNeXt-50 is shown only without PID because jet images cannot straightforwardly incorporate that information.
  • Results: 10%–15% higher background rejection results from adding PID inputs compared with the same model without PID.The comparison demonstrates that particle-based representations can integrate additional per-particle information.
  • Results: Almost 15% improvement in background rejection over PFN-Ex and P-CNN is achieved by ParticleNet with PID inputs.ParticleNet-Lite achieves the second-best performance, improving about 7% over PFN-Ex and P-CNN.

V. MODEL COMPLEXITY

ParticleNet delivers the best classification performance among the compared top-tagging models, but its higher performance comes with substantially greater inference cost. ParticleNet-Lite offers a more favorable speed–performance balance and uses the fewest parameters.

  • ParticleNet achieves the best classification performance but is more than an order of magnitude slower than PFN and P-CNN.The comparison uses inference time per object, measured separately on CPU and GPU.
  • ParticleNet-Lite improves performance by more than 40% while running only a few times slower than PFN and P-CNN.
  • ParticleNet-Lite is the most economical model, with 26k parameters, while outperforming all previous approaches.Its performance is attributed to effective exploitation of particle-cloud permutation symmetry.
  • PFN is the fastest model on both CPU and GPU, making it suitable for extremely time-critical tasks.

VI. CONCLUSION

The paper introduces particle clouds—unordered sets of jet particles—as the basis for ParticleNet, a jet-tagging architecture. ParticleNet achieves state-of-the-art performance on both top-tagging and quark–gluon-tagging benchmarks and significantly improves over existing methods.

  • ParticleNet treats jets as unordered particle clouds and uses this representation in a network architecture tailored to jet tagging.
  • ParticleNet achieves state-of-the-art performance on both top-tagging and quark–gluon-tagging benchmarks.
  • ParticleNet significantly improves over image-based ResNeXt-50, sequence-based P-CNN, and set-based PFN architectures.

Appendix A: Implementation details of ResNeXt-50

The appendix describes the input construction and training setup for the ResNeXt-50 and P-CNN comparison models. ResNeXt-50 uses 64 × 64 jet images, while P-CNN processes fixed-length particle sequences.

  • Implementation details of ResNeXt-50: ResNeXt-50 represents each jet as a 64 × 64 image whose pixel intensities contain rescaled summed particle pT.Pixels correspond to 0.025 rad granularity in pseudorapidity–azimuth space.
  • Implementation details of ResNeXt-50: ResNeXt-50 adapts the original architecture by reducing channels in most convolutional layers and adding dropout with probability 0.5.
  • Implementation details of ResNeXt-50: ResNeXt-50 is trained for 30 epochs with Adam, minibatches of 256, and learning-rate reductions at epochs 10 and 20.The final model is selected using validation accuracy.
  • Implementation details of P-CNN: P-CNN represents each jet as a sequence of 100 particles sorted by descending pT, padding shorter jets and truncating longer ones.
  • Implementation details of P-CNN: P-CNN uses 14 one-dimensional convolutional layers followed by global pooling, a 512-unit fully connected layer, dropout, and classification output.
  • Implementation details of P-CNN: P-CNN is trained for 30 epochs with Adam, minibatches of 1024, and learning-rate reductions at epochs 10 and 20.The final model is selected using validation accuracy.
Loading 1902.08570v3…