Comparing Classical and Quantum Machine Learning for Regression in High Energy Physics Collision Data

Tariq Mahmood; Zain ul Abidin; Itzel Luviano Soto; Alfredo Raya

Source-linked AI summary

Comparing Classical and Quantum Machine Learning for Regression in High Energy Physics Collision Data

Tariq Mahmood, Zain ul Abidin, Itzel Luviano Soto, Alfredo Raya

arXiv:2608.28084v1Aug 28, 2026cs.LGhep-exhep-phhep-thquant-ph

TL;DR

High-energy-physics collision analysis requires scalable regression and classification for large datasets. This paper compares classical and quantum architectures on simulated LHC events, finding slightly stronger classical performance but much greater quantum parameter efficiency. The results characterize resource trade-offs under current constraints.

Problem
Direct comparisons spanning full classical and quantum architecture suites on a single HEP dataset remain scarce.
Method
The study evaluates four classical and four quantum architectures on simulated pp collision events, using transverse-momentum components to predict transverse-momentum magnitude.
Results
Classical models achieve marginally better quantitative performance, while quantum architectures reach competitive accuracy with one to three orders of magnitude fewer trainable parameters.
Takeaways & Limitations
The comparison characterizes trade-offs between predictive performance and parameter efficiency under current CPU-based simulation and NISQ-era constraints.

Abstract

from arXiv · show

The classification and regression of particle collision events constitute a persistent computational challenge in experimental high energy physics, where large volumes of simulated data must be processed with both speed and precision. This work carries out a systematic comparison of four classical machine learning architectures, support vector machines (SVM), artificial neural networks (ANN), convolutional neural networks (CNN), and long short-term memory (LSTM) networks against their quantum counterparts: quantum SVM (QSVM), quantum neural networks (QNN), quantum CNN (QCNN), and quantum LSTM (QLSTM). All models are trained on simulated proton-proton collision events with electron-positron and muon-antimuon final states from the CERN Open Data portal, using transverse-momentum components as input features and transverse-momentum magnitude as the regression target. Classical architectures, and in particular the CNN and LSTM, achieve marginally better quantitative performance under current hardware and dataset constraints. Quantum models, however, reach competitive accuracy with substantially fewer trainable parameters: the QCNN reproduces the performance of the deep classical CNN using only four qubits and a circuit of depth three, pointing to a genuine parameter-efficiency advantage on near-term quantum devices. A baseline analysis confirms that the regression problem is non-trivial for shallow polynomial fits, supporting the relevance of the architectural comparison. These results characterize the trade-offs between classical and quantum approaches under realistic, resource-constrained conditions and provide a benchmark for future studies on actual quantum hardware.

I. INTRODUCTION

HEP experiments generate enormous collision datasets, motivating scalable machine-learning analysis. This study compares classical and quantum architectures under current NISQ-era constraints using simulated LHC events.

Modern LHC runs generate petabytes of collision records, driving machine-learning adoption across the experimental pipeline.
Deep learning, including CNNs and recurrent models, has been applied to jet tagging and particle identification.
Quantum machine learning combines quantum-circuit representations with classical pattern-recognition methods.
The practical scope of quantum advantage on noisy intermediate-scale quantum devices remains under active investigation.
The study compares four classical architectures with quantum analogs on simulated LHC events to characterize trade-offs under current hardware constraints.The data include proton-proton events with e+e− and µ+µ− final states; transverse-momentum components are inputs and magnitude is the target.

A. Classical machine learning in HEP

Classical and quantum machine learning have established HEP applications across classification, reconstruction, and sequential learning. However, direct comparisons of broad architecture suites on one HEP dataset remain scarce, motivating this unified benchmark.

ANNs have supported HEP triggering, event reconstruction, particle identification, calorimeter estimation, mass measurement, and Higgs searches.
CNNs exploit spatial locality when detector data are represented as image-like arrays.They have been applied to event discrimination and sparse detector geometries.
An LSTM achieved a background rejection factor of 100 at 50% signal efficiency in a pp-collision benchmark.
QSVMs estimate quantum-kernel matrices through circuits before delegating optimization to a classical solver.Prior Higgs-event classification results reached 80–85% ROC area on 10–20 qubits.
QCNNs reached 97.5% accuracy in two of three HEP classification tasks, while QLSTMs replace classical gates with variational quantum circuits.
Direct comparisons spanning four classical and four quantum architectures on one HEP dataset remain scarce.This work addresses the gap with a unified protocol and polynomial regression baseline.

III. METHODOLOGY

The methodology uses simulated proton-proton events and a deterministic transverse-momentum regression target. Models are evaluated after feature normalization and an 80/20 train-test split with multiple standard error metrics.

A. Dataset: The dataset contains simulated pp events with e+e− and µ+µ− final states and multiple kinematic variables.
A. Dataset: The regression uses px1 and py1 as input features and ptl1 as the target variable.
A. Dataset: The target relationship is smooth and deterministic, allowing sufficiently capable models to approximate it well.Polynomial baselines are included to characterize the problem's difficulty.
Features are min-max normalized, and the data are partitioned 80/20 for training and testing.Evaluation uses MAE, MSE, RMSE, and R2.

B. Polynomial regression baselines

Polynomial regressors provide a diagnostic baseline for judging whether the regression supports meaningful architectural comparisons. The surrounding methodology describes neural-network optimization and classical SVM regression concepts used for comparison.

B. Polynomial regression baselines: Degree-1 and degree-4 polynomial regressors are fitted by ordinary least squares as diagnostic baselines.Matching complex models would weaken architectural conclusions, whereas outperforming baselines increases interpretive value.
SVM regression seeks a flat function whose deviations from targets remain within tolerance ε, using kernels to evaluate transformed-space inner products.
Feedforward ANNs stack nonlinear units into hidden layers and train by minimizing a loss through backpropagation and gradient-based optimization.
Figure 1 depicts an SVM boundary and margin, with support vectors closest to the hyperplane determining the optimal boundary.
The ANN implementation uses one to four fully connected hidden layers with 100 neurons each, ReLU activations, and a linear output neuron.Training minimizes MSE with Adam in TensorFlow/Keras.
Figure 2 contrasts a single nonlinear artificial neuron with a multilayer network containing input, hidden, and output layers.

3. Convolutional neural networks

The study applies a one-dimensional CNN to kinematic feature sequences, using convolution and pooling to extract and reduce local patterns before regression.

3. Convolutional neural networks: Convolutional layers extract local features from kinematic sequences.The architecture uses learnable filters to produce feature maps encoding local patterns.
3. Convolutional neural networks: Pooling reduces dimensionality and introduces a degree of translational invariance.
3. Convolutional neural networks: A dense linear output layer produces the regression estimate.

4. Long short-term memory networks

The supplied passages describe quantum and recurrent architectures that process data through parameterized circuits, quantum kernels, or gated memory mechanisms.

4. Long short-term memory networks: LSTMs regulate memory with input, forget, and output gates to address long-range dependency learning problems.
4. Long short-term memory networks: The QSVM evaluates a quantum kernel after embedding classical data points into quantum states.The resulting kernel matrix is passed to a classical SVM optimizer.
4. Long short-term memory networks: The quantum kernel matrix is pre-computed by running the circuit for all training pairs.PennyLane estimates the kernel, while scikit-learn performs optimization.
4. Long short-term memory networks: QNNs use trainable rotation angles, angle embedding, entangling gates, and measurements to produce predictions.Their parameter-efficiency rationale is linked to the exponentially large Hilbert space of quantum states.

3. Quantum convolutional neural networks

The quantum architectures mirror classical structural ideas while implementing feature processing and gating with variational quantum circuits and qubit operations.

3. Quantum convolutional neural networks: QCNNs combine local feature extraction with pooling inside a quantum circuit.Quantum convolutional layers use parameterized two-qubit gates on neighboring qubits, while pooling reduces active qubits through controlled measurements.
3. Quantum convolutional neural networks: QLSTM gates are implemented as variational quantum circuits receiving current-input and previous-hidden-state vectors.An additional circuit transforms the updated cell state into the new hidden state.
3. Quantum convolutional neural networks: 4 qubits and circuit depth 2 are used for the QLSTM implementation.
3. Quantum convolutional neural networks: Quantum-model parameter counts refer to rotation angles in variational circuits, whereas classical counts refer to total weights.

F. Implementation and evaluation protocol

The experiments use a unified CPU-based protocol and compare machine-learning architectures with polynomial baselines to assess regression difficulty.

F. Implementation and evaluation protocol: All models are trained and evaluated under a unified protocol using scikit-learn, TensorFlow/Keras, and PennyLane.All experiments run in a standard CPU environment.
F. Implementation and evaluation protocol: The experimental configuration and hyperparameters are summarized in Tables II and III.
A. Polynomial baseline: R2 = 0.0008 and MAE = 11.3082 are achieved by linear regression on the test set.A degree-4 expansion offers additional improvement, while the linear result indicates the problem is not trivially solvable by a linear model.
A. Polynomial baseline: The smooth, deterministic relationship in Eq. (1) creates a high performance ceiling for sufficiently flexible architectures.Polynomial baselines are included to characterize this intrinsic difficulty.

B. Comparative performance

Classical CNN and LSTM models provide the strongest quantitative regression performance, while quantum models remain competitive with far fewer trainable parameters. The results also reveal architecture-specific error patterns, including large QSVM residual outliers and weaker QLSTM performance under shallow-circuit constraints.

Diagnostic comparisons: Figures 4–6 assess regression quality through true-versus-predicted alignment and comparisons between actual and predicted transverse-momentum distributions.Diagonal alignment indicates accurate regression, while distribution overlap indicates that models capture the target's statistical structure beyond its mean.
Classical architectures: R2 = 1.000 with MAE = 0.0051, the CNN delivers the tightest classical predictions, while the LSTM achieves the lowest MSE of any model (MSE = 0.0001).The ANN reaches R2 = 0.999996 with MAE = 0.0234, whereas the classical SVM has R2 = 0.9936 and higher absolute errors.
Quantum architectures: MAE = 0.1776 but MSE = 8.8446 for QSVM indicates relatively accurate median-scale trends alongside isolated large-residual predictions.The reported outliers exceed 5σ; removing them would bring QSVM MSE within a factor of two of its classical counterpart.
Quantum architectures: A 90-fold reduction in parameter count costs approximately 0.9 percentage points in R2: the QCNN reaches R2 = 0.9907 with 36 parameters versus the classical CNN's R2 = 1.000 with nearly 3,300 parameters.The QNN achieves R2 = 0.9948 with 96 trainable parameters, roughly 310 times fewer than the ANN it approximates.
Quantum architectures: MSE = 6.1387 makes QLSTM the weakest quantum model by MSE, although it still achieves accuracy above 99.5%.The elevated MSE is attributed most likely to shallow circuit depth (d = 2) and the limited expressivity of four qubits for sequential processing.

C. Parameter efficiency and scaling outlook

Quantum architectures maintain high regression performance with dramatically fewer trainable parameters, but parameter count alone does not establish hardware efficiency. Current NISQ depth constraints and quantum-specific resource costs limit stronger conclusions.

R2 > 0.97 is achieved by quantum architectures with one to three orders of magnitude fewer parameters than classical counterparts.This pattern persists across all four classical–quantum model pairs.
NISQ depth constraints restrict QCNN and QLSTM from closing the performance gap entirely.
Parameter count alone is insufficient for hardware-efficiency conclusions because quantum circuits also require coherence, gate fidelity, and repeated measurement shots.A complete analysis would need to include the shot budget alongside parameter count.

V. CONCLUSION

The study compares classical and quantum architectures for regression on simulated LHC collision events, using polynomial baselines to assess problem difficulty. Classical models perform marginally better quantitatively, while quantum models achieve competitive accuracy with far fewer parameters; the QCNN provides a concrete example of this trade-off.

Classical models achieve marginally better quantitative performance, while quantum architectures use one to three orders of magnitude fewer trainable parameters.
Polynomial baselines characterize the intrinsic difficulty of the simulated proton-proton collision regression problem.
36 variational parameters yield QCNN R2 = 0.9907, compared with approximately 3,300 parameters for the classical CNN at R2 = 1.000.