On the Applicability of Quantum Machine Learning

1. Related Work

Considerable research was conducted in the last years to advance quantum machine learning environments and their application field. This starts in the data encoding process, in which Schuld and Killoran [3]investigated quantum machine learning in feature Hilbert spaces theoretically. They proposed a framework for constructing quantum embeddings of classical data to enable quantum algorithms that learn and classify data in quantum feature spaces.

Further research was conducted on introducing novel architectural frameworks. For such, Mitarai et al. [18] presented a method called quantum circuit learning (QCL), which uses parameterized quantum circuits to approximate classical functions. QCL can be applied to supervised and unsupervised learning tasks, as well as reinforcement learning.

Havlíček et al. [4] introduced a quantum-enhanced feature space approach using variational quantum circuits. This work demonstrated that quantum computers can effectively process classical data with quantum kernel methods, offering the potential for exponential speedup in certain applications.

Furthermore, Farhi and Neven [5] explored the use of quantum neural networks for classification tasks on near-term quantum processors. They showed that quantum neural networks can achieve good classification performance with shallow circuits, making them suitable for noisy intermediate-scale quantum (NISQ) devices.

Other research focused on the advancement of applying quantum fundamentals on classical machine learning applications. Hereby, Rebentrost et al. [19] introduced the concept of a quantum support vector machine for big data classification. They showed that the quantum version of the algorithm can offer exponential speedup compared to its classical counterpart, specifically in the kernel evaluation stage.

To advance the application field of Quantum Machine Learning, Liu and Rebentrost [20] proposed a quantum machine learning approach for quantum anomaly detection. They demonstrated that their method can efficiently solve classification problems, even when the data has a high degree of entanglement.

In this regard, it is worth mentioning the work of Broughton et al. [21] introduced TensorFlow Quantum, an open-source library for the rapid prototyping of hybrid quantum-classical models for classical or quantum data. They demonstrated various applications of TensorFlow Quantum, including supervised learning for quantum classification, quantum control, simulating noisy quantum circuits, and quantum approximate optimization. Moreover, they showcased how TensorFlow Quantum can be applied to advanced quantum learning tasks such as meta-learning, layerwise learning, Hamiltonian learning, sampling thermal states, variational quantum eigensolvers, classification of quantum phase transitions, generative adversarial networks, and reinforcement learning.

In the review paper by Zeguendry et al. [17], the authors present a comprehensive overview of quantum machine learning (QML) from the perspective of conventional machine learning techniques. The paper starts by exploring the background of quantum computing, its architecture, and an introduction to quantum algorithms. It then delves into several fundamental algorithms for QML, which form the basis of more complex QML algorithms and can potentially offer performance improvements over classical machine learning algorithms. In the study, the authors implement three machine learning algorithms: Quanvolutional Neural Networks, Quantum Support Vector Machines, and Variational Quantum Classifier (VQC). They compare the performance of these quantum algorithms with their classical counterparts on various datasets. Specifically, they implement Quanvolutional Neural Networks on a quantum computer to recognize handwritten digits and compare its performance to Convolutional Neural Networks, stating the performance improvements by quantum machine learning.

Despite these advancements, it is important to note that some of the discussed papers may not have used randomized search CV from scikit-learn to optimize the classical machine learning algorithms, thereby, overstating the significance of quantum supremacy. Nevertheless, the above-mentioned works present a comprehensive overview of the state of the art in quantum machine learning for classification, highlighting the potential benefits of using quantum algorithms in various forms and applications.

2. Methodology

This section presents our methodology for comparing the performance of classical and quantum machine learning techniques for classification tasks. Our approach is designed to provide a blueprint for future experiments in this area of research. We employ the Scikit-learn library, focusing on the inbuilt functions to select a good set of hyperparameters, i.e., RandomizedSearchCV to compare classical and quantum machine learning models. We also utilize the Qiskit library to incorporate quantum machine learning techniques into our experiments, [22]. The selected data sets for our study include both real-world and synthetic data, enabling a comprehensive evaluation of the classifiers’ performance.

2.1. Supervised Machine Learning

Supervised Machine Learning is a subfield of artificial intelligence that focuses on developing algorithms and models to learn patterns and make decisions or predictions based on data [23,24]. The main goal of supervised learning is to predict labels or outputs of new, unseen data given a set of known input-output pairs (training data). This section briefly introduces several classical machine learning techniques used for classification tasks, specifically in the context of supervised learning. These techniques serve as a baseline to evaluate the applicability of quantum machine learning approaches, which are the focus of this paper. Further, we will then introduce the employed quantum machine learning algorithms.

One of the essential aspects of supervised machine learning is the ability to predict/classify data. The models are trained using a labeled dataset, and then the performance of the models is evaluated based on their accuracy in predicting the labels of previously unseen test samples [25]. This evaluation is crucial to estimate the model’s ability to generalize the learned information when making predictions on new, real-world data.

Various techniques, such as cross-validation and train-test splits, are often used to obtain reliable performance estimates of the models [26]. By comparing the performance of different models, researchers and practitioners can determine which model or algorithm is better suited for a specific problem domain.

2.2. Classical Supervised Machine Learning Techniques

The following list describes the employed algorithms that serve as a baseline for the afterwards described and later tested quantum machine learning algorithms.

• Lasso and Ridge Regression/Classification: Lasso (Least Absolute Shrinkage and Selection Operator) and Ridge Regression are linear regression techniques that incorporate regularization to prevent overfitting and improve model generalization [10,27]. Lasso uses L1 regularization, which tends to produce sparse solutions, while Ridge Regression uses L2 regularization, which prevents coefficients from becoming too large.
  Both of these regression algorithms can also be used for classification tasks.
• Multilayer Perceptron (MLP): MLP is a type of feedforward artificial neural network with multiple layers of neurons, including input, hidden, and output layers [14]. MLPs are capable of modeling complex non-linear relationships and can be trained using backpropagation.
• Support Vector Machines (SVM): SVMs are supervised learning models used for classification and regression tasks [28]. They work by finding the optimal hyperplane that separates the data into different classes, maximizing the margin between the classes.
• Gradient Boosting Machines: Gradient boosting machines are an ensemble learning method that builds a series of weak learners, typically decision trees, to form a strong learner [29]. The weak learners are combined by iteratively adding them to the model while minimizing a loss function. Notable gradient boosting machines for classification tasks include XGBoost [9], CatBoost [13], and LightGBM [12]. These three algorithms have introduced various improvements and optimizations to the original gradient boosting framework, such as efficient tree learning algorithms, handling categorical features, and reducing memory usage.

2.3. Quantum Machine Learning

Quantum machine learning is an emerging interdisciplinary field that leverages the principles of quantum mechanics and quantum computing to improve or develop novel algorithms for machine learning tasks [2]. This section introduces two key quantum machine learning techniques, Variational Quantum Classifier (VQC) and Quantum Kernel Estimator (QKE), and discusses their connections to classical machine learning techniques. Additionally, we briefly introduce Qiskit Machine Learning, a Python package developed by IBM for implementing quantum machine learning algorithms. Also, we want to mention the work done by [17] for a review of quantum machine learning algorithms and a more detailed discussion of the employed algorithms.

2.3.1. Variational Quantum Classifier (VQC):

VQC is a hybrid quantum-classical algorithm that can be viewed as a quantum analog of classical neural networks, specifically the Multilayer Perceptron (MLP) [4]. VQC employs a parametrized quantum circuit, which is trained using classical optimization techniques to find the optimal parameters for classification tasks. The learned quantum circuit can then be used to classify new data points.

Figure 1 illustrates the schematic depiction of the Variational Quantum Circuit (VQC), which involves preprocessing the data, encoding it onto qubits using a feature map, processing it through a variational quantum circuit (Ansatz), measuring the final qubit states, and optimizing the circuit parameters $\theta$, Thus the main building blocks of the VQC are:

• Preprocessing: The data is prepared and preprocessed before being encoded onto qubits.
• Feature Map Encoding (yellow in the figure): The preprocessed data is encoded onto qubits using a feature map.
• Variational Quantum Circuit (Ansatz) (steel-blue in the figure): The encoded data undergoes processing through the variational quantum circuit, also known as the Ansatz, which consists of a series of quantum gates and operations.
• Measurement (orange in the figure): The final state of the qubits is measured, providing probabilities for the different quantum states.
• Parameter Optimization: The variational quantum circuit is optimized by adjusting the parameters $\theta$, such as the rotations of specific quantum gates, to improve the outcome/classification.

2.3.2. Quantum Kernel Estimator (QKE):

QKE is a technique that leverages the quantum computation of kernel functions to enhance the performance of classical kernel methods, such as Support Vector Machines (SVM) [30].By computing the kernel matrix using quantum circuits, QKE can capture complex data relationships that may be challenging for classical kernel methods to exploit.

The main building blocks for the employed QKE, which are depicted in Figure 2 are:

• Data Preprocessing: The input data is preprocessed, which may include tasks such as data cleaning, feature scaling, or feature extraction. This step ensures that the data is in an appropriate format for the following quantum feature maps.
• Feature Map Encoding (yellow in the figure): The preprocessed data is encoded onto qubits using a feature map.
• Kernel Computation (steel-blue in the figure): Instead of directly computing the kernel matrix from the original data, a kernel function is precomputed using the quantum computing capabilities, meaning that the inner product of two quantum states is estimated on a quantum simulator/circuit. This kernel function captures the similarity between pairs of data points in a high-dimensional feature space.
• SVM Training: The precomputed kernel function is then used as input to the SVM algorithm for model training. The SVM aims to find an optimal hyperplane that separates the data points into different classes with the maximum margin.

Here we need to mention that in the documentation of qiskit-machine-learning, the developers provided a full QKE implementation without the need to use, e.g., scikit-learn’s SVM-implementation. However, as of the writing of this article, this estimator is no longer available in qiskit-machine-learning. Thus, one needs to use a support vector machine implementation from other sources after precomputing the kernel on a quantum simulator.

2.3.3. Qiskit Machine Learning

Qiskit Machine Learning is an open-source Python package developed by IBM for implementing quantum machine learning algorithms [22]. This package enables researchers and practitioners to develop and test quantum machine learning algorithms, including VQC and QKE, using IBM’s quantum computing platform. It provides tools for building and simulating quantum circuits, as well as interfaces to classical optimization and machine learning libraries.

Thus we used this environment and the corresponding Quantum Simulators described in Appendix A for our experiments.

2.4. Accuracy Score for Classification

The accuracy score is a standard metric used to evaluate the performance of classification algorithms. We employed the accuracy score to evaluate all presented experiments. It is defined as the ratio of correct predictions to the total number of predictions. The formula for the accuracy score is defined as follows:

$$\mathrm{Accuracy}=\frac{\mathrm{Number}\mathrm{of}\mathrm{correct}\mathrm{predictions}}{\mathrm{Total}\mathrm{number}\mathrm{of}\mathrm{predictions}}$$

(1)

In Scikit-learn, the accuracy score can be computed using the accuracy_score function from the `sklearn.metrics` module [15].

For more information on the accuracy score and its interpretation, refer to the Scikit-learn documentation [15].

2.5. Data Sets

In this study, we used six classification data sets from various sources. Two data sets are part of the Scikit-learn library, while the remaining four are obtained/fetched from OpenML. The data sets are described below:

• Iris Data Set: A widely known data set consisting of 150 samples of iris flowers, each with four features (sepal length, sepal width, petal length, and petal width) and one of three species labels (Iris Setosa, Iris Versicolor, or Iris Virginica). This data set is included in the Scikit-learn library [15].
• Wine Data Set: A popular data set for wine classification, which consists of 178 samples of wine, each with 13 features (such as alcohol content, color intensity, and hue) and one of three class labels (class 1, class 2, or class 3). This data set is also available in the Scikit-learn library [15].
• Indian Liver Patient Dataset (LPD): This data set contains 583 records, with 416 liver patient records and 167 non-liver patient records [31]. The data set includes ten variables: age, gender, total bilirubin, direct bilirubin, total proteins, albumin, A/G ratio, SGPT, SGOT, and Alkphos. The primary task is to classify patients into liver or non-liver patient groups.
• Breast Cancer Coimbra Dataset: This data set consists of 10 quantitative predictors and a binary dependent variable, indicating the presence or absence of breast cancer [32,33]. The predictors are anthropometric data and parameters obtainable from routine blood analysis. Accurate prediction models based on these predictors can potentially serve as a biomarker for breast cancer.
• Teaching Assistant Evaluation Dataset: This data set includes 151 instances of teaching assistant (TA) assignments from the Statistics Department at the University of Wisconsin-Madison, with evaluations of their teaching performance over three regular semesters and two summer semesters [34,35]. The class variable is divided into three roughly equal-sized categories ("low", "medium", and "high"). There are six attributes, including whether the TA is a native English speaker, the course instructor, the course, the semester type (summer or regular), and the class size.
• Impedance Spectrum of Breast Tissue Dataset: This data set contains impedance measurements of freshly excised breast tissue at the following frequencies: 15.625, 31.25, 62.5, 125, 250, 500, and 1000 KHz [36,37]. The primary task is to predict the classification of either the original six classes or four classes by merging the fibro-adenoma, mastopathy, and glandular classes whose discrimination is not crucial.

These data sets were selected for their diverse domains and varied classification tasks, providing a robust testing ground for the quantum classifiers we employed in our experiments.

Further, we used artificially generated data sets to control the number of samples, etc.. Here scikit-learn provides a valuable function called make_classification to generate synthetic classification datasets. This function creates a random n-class classification problem, initially creating clusters of points normally distributed about vertices of an n-informative-dimensional hypercube, and assigns an equal number of clusters to each class [15]. It introduces interdependence between features and adds further noise to the data. The generated data is highly customizable, with options for specifying the number of samples, features, informative features, redundant features, repeated features, classes, clusters per class, and more. For more details on the make_classification function and its parameters, refer to the Scikit-learn documentation available on scikit-learn.org.

2.5.1. Data Obtained from Lie-Algebras

We construct another artificial data set final data set for our final evaluation; however, this time, we do this by using tools from the theory of Lie groups. The reason for employing these concepts is that we want to produce data that resembles the complexity inherent to the Qubit-Vectorspace of quantum machine learning and, further, is generated by applying transformations on vectors that are similar to the manipulations present in Quantum Machin Learning algorithms, e.g., for the VQC, rotations of/around the Bloch-sphere. Thus we overall aim to provide random data for a classification task to show a case where the authors assume Quantum Machine Learning algorithms can, because of their inherent structure, outperform classical machine learning algorithms and thus provide a prototype on the type of data specifically tailored to address the inherent structure of quantum machine learning. The theoretical foundations of this section are obtained from [38], and thus the interested reader is referred to this book for a profound introduction to Lie groups.

To further explain the employed ideas, we start by introducing the concept of a Lie group G and the corresponding Lie-algebra $\mathcal{g}$.

A Lie group is a mathematical structure that captures the essence of continuous symmetry. Named after the Norwegian mathematician Sophus Lie, Lie groups are ubiquitous in many areas of mathematics and physics, including the study of differential equations, geometry, and quantum mechanics.

A Lie group is a set G that has the structure of both a smooth manifold and a group in such a way that the group operations (multiplication and inversion) are smooth. That is, a Lie group is a group that is also a differentiable manifold, such that the group operations are compatible with the smooth structure.

Meaning that a Lie group is a set G equipped with a group structure (i.e., a binary operation $G\times G\to G$, $(g,h)\mapsto gh$ that is associative, an identity element $e\in G$, and an inversion operation $G\to G$, $g\mapsto g^{-1}$) and a smooth manifold structure such that the following conditions are satisfied:

• The multiplication map $\mu :G\times G\to G$ defined by $\mu (g,h)=gh$ is smooth.
• The inversion map $\iota :G\to G$ defined by $\iota \left(g\right)=g^{-1}$ is smooth.

A Lie algebra is associated with each Lie group, a vector space equipped with a binary operation called the Lie bracket. The Lie algebra captures the local structure of the Lie group near the identity element, meaning that the Lie algebra of a Lie group G is the tangent space at the identity, denoted $T_{e}G$, equipped with the Lie bracket operation. The Lie bracket is defined in terms of the group operation and the differential.

There is a map from the Lie algebra to the Lie group called the exponential map, denoted $exp:T_{e}G\to G$. The exponential map provides a way to generate new group elements from elements of the Lie algebra. In particular, given an element X of the Lie algebra, $exp\left(X\right)$ is a group element close to the identity if X is ’small’. We will exploit this concept to generate random data associated with a specific group:

We start with a set of Generators $T_a$ contained within the Lie-algebra g of a Lie group G, where $a=1,2,\cdots d_{\mathfrak{g}}$, i.e., the dimension of the Lie-algebra. We can then create elements $g\in G$ by employing

$$g=e^{i{\sum }_a{\theta }_a{T}_a},\mathrm{where}{\theta }_a\in \left[0,2\pi \right].$$

(2)

We used the condition for our ${\theta }_a$-values without loss of generality due to the periodicity of the exponential function. To generate our random data, we randomly choose our ${\theta }_a$ and create an element of our group. We then apply this element to a corresponding base vector of our vector space.

Specifically, in our example, we use the Lie-group SU(2). The special unitary group of degree 2, denoted as SU(2), is a Lie group of 2x2 unitary matrices with determinant 1.

$$\mathrm{SU}\left(2\right)=\left\{U\in {\mathbb{C}}^{2x2}:U{U}^{†}=I,\det \left(U\right)=1\right\}$$

(3)

The corresponding Lie algebra, $\mathfrak{su}\left(2\right)$, consists of 2x2 Hermitian traceless matrices, i.e. the Pauli matrices:

$${\sigma }_1=\left(\begin{array}{cc}0& 1\\ 1& 0\end{array}\right),{\sigma }_2=\left(\begin{array}{cc}0& -i\\ i& 0\end{array}\right),{\sigma }_3=\left(\begin{array}{cc}1& 0\\ 0& -1\end{array}\right)$$

(4)

The commutation relations of the Pauli matrices form the structure of the $\mathfrak{su}\left(2\right)$ Lie algebra:

$$[{\sigma }_i,{\sigma }_j]=2i{\epsilon }_{ijk}{\sigma }_k$$

(5)

where $[·,·]$ denotes the commutator, and ${\epsilon }_{ijk}$ is the Levi-Civita symbol.

To generate a classification data set from this algebra, we use the following procedure:

• Find a set of random parameters $\theta \in \left(0;\pi \right],\varphi \in \left(0;2\pi \right],\lambda \in \left(0;2\pi \right]$
• We then create an element U of SU(2) using these these randomly set parameters: $U=e^{i\left(\theta {\sigma }_1+\varphi {\sigma }_2+\lambda {\sigma }_3\right)}$
• Next we take one of the basevectors from ${\mathbb{C}}^2$, denoted as $\widehat{v}$ to create a new complex vector $\overrightarrow{v}$ using the previously obtained matrix U such that: $\overrightarrow{v}=U·\widehat{v}$.
• This vector is then separated into four features $F_j$ such that:

  $$\begin{array}{c}\hfill F_1=\mathfrak{Re}\left[v_1\right]\end{array}$$

  (6)

  $$\begin{array}{c}\hfill F_2=\mathfrak{Im}\left[v_1\right]\end{array}$$

  (7)

  $$\begin{array}{c}\hfill F_3=\mathfrak{Re}\left[v_2\right]\end{array}$$

  (8)

  $$\begin{array}{c}\hfill F_4=\mathfrak{Im}\left[v_2\right],\end{array}$$

  (9)

  where $v_1$ and $v_2$ denotes the individual components of the vector $\overrightarrow{v}$.
• Finally we assign a class label C to this collection of Features such that:

  $$C=\left\{\begin{array}{cc}0\hfill & \mathrm{if}\theta <\frac{\pi }{2}\hfill \\ 1\hfill & \mathrm{if}\theta >\frac{\pi }{2}\hfill \end{array}\right.,$$

  (10)

  and collect the features and the class label into one sample $\left[F_1,F_2,F_3,F_4,C\right]$. We repeat this process $N_S$ times, starting with 1., where $N_S$ is the number of samples that we want for our data set.

Note that this approach can be extended to arbitrary Lie groups, given that one can construct or obtain a Lie group’s generators.

3. Experimental Design

In this section, we describe our experimental design, which aims to provide a fair and comprehensive comparison of the performance of classical machine learning (ML) and quantum machine learning (QML) techniques, as discussed in Section 2.2 and Section 2.3. Our experiments involve two main components: Firstly, assessing the algorithms’ performance on artificially generated data sets with varying parametrizations, and secondly, evaluating the algorithms’ performance on benchmark data sets using randomized search to optimize hyperparameters, ensuring a fair comparison. By carefully selecting our experimental setup, we avoid the issue of "cherry-picking" only a favorable subset of results, a common problem in machine learning leading to heavily-biased conclusions.

3.1. Artificially Generated Sci-Kit Data Sets

To generate the synthetic classification dataset, we utilized scikit-learn’s

make_classification function. We employed two features and two classes while varying the number of samples to obtain a performance curve illustrating how the chosen algorithms’ performance changes depending on the sample size.

We partitioned each dataset such that 20% of the original data was reserved as a test set to evaluate the trained algorithm, producing the accuracy score used for our assessment. Further, each data set was normalized such that all features are within the unit interval $\left[0,1\right]$.

As a baseline, we employed the seven classical machine learning algorithms described in Section 2.2, namely Lasso, Ridge, MLP, SVM, XGBoost, LightGBM, and CatBoost. We used two different parameterizations for the classical machine learning algorithms for our comparisons. Firstly, we applied the out-of-the-box implementation without any hyperparameter optimization. Secondly, we used an optimized version of each algorithm found through scikit-learn’s RandomizedSearchCV by testing 20 different models.

We then examined 20 distinct parameter configurations, each for the VQC and QKE classifiers, randomly selected from a predefined parameter distribution. Appendix A discusses the parameter grids for all utilized algorithms and all experiments.

3.2. Artificially Generated SU(2) Data Sets

For our synthetic $SU\left(2\right)$ classification dataset, we used the concepts previously discussed in Section 2.5.1. We employed two complex features, i.e. resulting in four continuous real features, and two classes while varying the number of samples to obtain a performance curve illustrating how the chosen algorithms’ performance changes depending on the sample size.

We partitioned each dataset such that 20% of the original data was reserved as a test set to evaluate the trained algorithm, producing the accuracy score used for our assessment. Further, each data set was normalized such that all features are within the unit interval $\left[0,1\right]$.

As a baseline, we employed the seven classical machine learning algorithms described in Section 2.2, namely Lasso, Ridge, MLP, SVM, XGBoost, LightGBM, and CatBoost. We used two different parameterizations for the classical machine learning algorithms for our comparisons. Firstly, we applied the out-of-the-box implementation without any hyperparameter optimization. Secondly, we used an optimized version of each algorithm found through scikit-learn’s RandomizedSearchCV by testing 20 different models.

We then examined 20 distinct parameter configurations, each for the VQC and QKE classifiers, randomly selected from a predefined parameter distribution. Appendix A discusses the parameter grids for all utilized algorithms and all experiments.

3.3. Benchmark Data Sets and Hyperparameter Optimization

Our last experiment was to test the two employed quantum machine learning algorithms against the classical machine learning algorithms on six benchmark data sets (Section 2.5). For this reason, we employed scikit-learn’s RandomizedSearchCV to test 20 randomly parameterized models for each algorithm to report the best of these tests. Again we used a train-test-split to keep 20% of the original data to test the trained algorithm. Further, each data set was normalized such that all features are within the unit interval $\left[0,1\right]$.

4. Results

In this section, we present the results of our experiments, comparing the performance of classical machine learning (ML) and quantum machine learning (QML) techniques on both artificially generated data sets and benchmark data sets (Section 2.5). By analyzing the results, we aim to draw meaningful insights into the strengths and weaknesses of each approach and provide a blueprint for future studies in the area.

4.1. Performance on Artificially Generated Sci-Kit Data Sets

In this section, we compare the performance of quantum machine learning (QML) algorithms and classical machine learning (ML) algorithms on artificially generated classification datasets. The comprehensive experimental setup can be found in Section 3.1.

Regarding accuracy and runtime, our findings are presented in Table 1 and Table 2 and Figure 3, Figure 4, and Figure 5. While QML algorithms perform reasonably well, we observe that they are not a match for properly trained and/or sophisticated state-of-the-art classifiers. Even out-of-the-box implementations of state-of-the-art ML algorithms outperform QML algorithms on these artificially generated classification datasets.

The accuracy of the algorithms varies depending on the dataset size, with larger datasets posing more challenges. CatBoost performed best in our experiments, both out-of-the-box and when optimized in terms of high accuracy over all experiments. The Quantum Kernel Estimator (QKE) is the third-best algorithm overall in terms of accuracy, though it outperforms CatBoost regarding the runtime for CatBoost’s optimized version. XGBoost and Support Vector Classification (SVC) follow closely, with competitive performances in terms of accuracy. However, Variational Quantum Circuit (VQC) struggles to achieve high accuracy compared to sophisticated boosting classifiers or support vector machines.

Other algorithms, such as Multi-Layer Perceptron (MLP), Ridge regression, Lasso regression, and LightGBM, exhibit varying performances depending on data set size and optimization. Despite some reasonable results from QKE, we conclude that classical ML algorithms, particularly sophisticated boosting classifiers, should be chosen to tackle similar problems due to their ease of implementation, better runtime, and overall superior performance.

In summary, while QML algorithms have shown some promise, they cannot yet compete with state-of-the-art classical ML algorithms on artificially generated classification datasets in terms of accuracy and runtime.

4.2. Performance on Artificially Generated SU2 Data Sets

In this section, we compare the performance of quantum machine learning (QML) algorithms and classical machine learning (ML) algorithms on artificially generated classification datasets based on Lie group structures. The detailled experimental setup can be found in Section 3.2.

Regarding accuracy and runtime, our findings are presented in Table 3 and Table 4 and Figure 6, Figure 7, and Figure 8. While QML algorithms perform reasonably well, we observe that they are not a match for properly trained and/or sophisticated state-of-the-art classifiers. Even out-of-the-box implementations of state-of-the-art ML algorithms outperform QML algorithms even on artificially generated classification datasets that are particularly suited for QML.

The accuracy of the algorithms varies depending on the dataset size, with larger datasets providing increased accuracy for most algorithms. CatBoost performed best in our experiments, both out-of-the-box and when optimized in terms of high accuracy over all experiments. The Quantum Kernel Estimator (QKE) is the fourth-best algorithm overall in terms of accuracy. However, we observe that, on average, CatBoost performs best over all experiments out of the box, but is outperformed by the best QKE implementation for 1000 and 1500 data points. Thus we conclude that Quantum Kernel estimators can capture the complexity of this $SU\left(2\right)$-generated data set, but overall, one is better off with an out-of-the-box CatBoost implementation. Meaning that we do not observe a quantum advantage for this type of data but rather that the employed quantum kernel estimator behaves similarly to classical machine learning algorithms, i.e., it exhibits reasonable performance but does not perform best for all data sets, even the ones created by exploiting quantum symmetry properties.

Other algorithms, such as Multi-Layer Perceptron (MLP), Ridge regression, Lasso regression, and LightGBM, exhibit varying performances depending on data set size and optimization. Despite some reasonable results from QKE, we conclude that classical ML algorithms, particularly sophisticated boosting classifiers, should be chosen to tackle similar problems due to their ease of implementation, better runtime, and overall superior performance.

In summary, while QML algorithms have shown some promise, they cannot yet compete with state-of-the-art classical ML algorithms even on these $SU\left(2\right)$-data sets, where the authors intended to provide evidence for the quantum advantage for data sets generated from symmetry properties inherent to quantum mechanics.

4.3. Results on Benchmark Data Sets

In this section, we discuss the performance of quantum machine learning (QML) and classical machine learning (ML) algorithms on six benchmark datasets described in Section 2.5. We include results for the quantum classifiers detailed in Section 2.3 and the classical machine learning classifiers discussed in Section 2.2. The scores/accuracies were obtained using Randomized Search cross-validation from Scikit-learn with 20 models and 5-fold cross-validation. Further, everything was calculated on our local machine using an Intel(R) Core(TM) i7-4770 CPU 3.40GHz and 16GB RAM.

Our results, shown in Table 5, display the best 5-fold cross-validation scores (upper table) and the scores of the best model evaluated on an unseen test subset of the original data (lower table), which makes up 20% of the original data. We observe varying performances of the algorithms on these benchmark datasets.

Notably, Variational Quantum Circuit (VQC) and Quantum Kernel Estimator (QKE) classifiers show competitive performance on several datasets but do not consistently outperform classical ML algorithms. In particular, QKE achieves a perfect score on the Iris dataset, but its performance varies across the other datasets.

Classical ML algorithms, such as Multi-Layer Perceptron (MLP), Support Vector Machines (SVM), XGBoost, LightGBM, and CatBoost, exhibit strong performance across all data sets, with some algorithms achieving perfect scores on multiple data sets. CatBoost consistently performs well, ranking as the top-performing algorithm on three of the six datasets. Ridge and Lasso regression show high accuracy on Iris and Wine datasets but perform poorly on the others.

When comparing the runtimes of the experiments, as presented in Table 6, it becomes evident that QML algorithms take substantially longer to execute than their classical counterparts. For instance, the VQC and QKE classifiers take hours to days to complete on various datasets, whereas classical ML algorithms such as Ridge, Lasso, MLP, SVM, XGBoost, LightGBM, and CatBoost typically take seconds to minutes.

This significant difference in runtimes could be attributed to the inherent complexity and resource requirements of QML algorithms, which generally demand specialized quantum hardware and simulators. On the other hand, classical ML algorithms are optimized for execution on conventional hardware, making them more efficient and faster to run.

In conclusion, while QML algorithms like VQC and QKE demonstrate potential in achieving competitive performance on certain datasets, their relatively longer runtimes and less consistent performance across the benchmark datasets may limit their practical applicability compared to classical ML algorithms. Classical ML algorithms such as CatBoost, XGBoost, and LightGBM continue to offer superior and more consistent performance with faster execution times, solidifying their place as reliable and powerful tools for classification tasks.

4.4. Comparison and Discussion

In this study, we have compared the performance of quantum machine learning (QML) and classical machine learning (ML) algorithms on six benchmark datasets and two types of artificially generated classification datasets. We included results for quantum classifiers, such as Variational Quantum Circuit (VQC) and Quantum Kernel Estimator (QKE), and classical machine learning classifiers like CatBoost, XGBoost, and LightGBM. Our experiments showed that while QML algorithms demonstrate potential in achieving competitive performance on certain datasets, they do not consistently outperform classical ML algorithms. Additionally, their longer runtimes and less consistent performance across the benchmark data sets may limit their practical applicability compared to classical ML algorithms, which continue to offer superior and more consistent performance with faster execution times. Further, we constructed artificial data sets with the structure and rulings of Quantum Mechanics in mind. I.e., we used symmetry properties and unitary transformations to generate a classification data set from $SU\left(2\right)$-matrices in order to demonstrate an advantage of quantum machine learning algorithms to tackle problems with an inherent structure relatable to that of quantum circuits and Quantum Mechanics overall. However, also for these data sets, the employed quantum machine learning algorithms performed reasonably but did not outperform sophisticated boost classifiers. Thus we cannot conclude a quantum advantage for these data sets.

It is essential to highlight that the QML algorithms’ performance in our experiments was based on simulated quantum infrastructures. This is a significant limitation to consider, as the specific constraints and characteristics of the simulated hardware may influence the performance of these algorithms. Further, given the rapid advancement of quantum technologies and hardware, this constraint might be obsolete in the near future.

The impact of quantum simulators, feature maps, and quantum circuits on the performance of quantum estimators stems from the fact that these components play crucial roles in shaping the behavior and capabilities of quantum machine learning algorithms. Quantum simulators, which emulate quantum systems on classical computers, introduce various levels of approximation and noise, leading to deviations from ideal quantum behavior. Different simulators may employ distinct algorithms and techniques, resulting in variations in performance.

Feature maps, responsible for encoding classical data into quantum states, determine how effectively the quantum system can capture and process information. The choice of feature map can greatly influence the ability of quantum algorithms to extract meaningful features and represent the data in a quantum-mechanical space.

Similarly, quantum circuits, composed of quantum gates and operations, define the computational steps performed on the encoded data. Different circuit designs and configurations can affect the expressiveness and depth of the quantum computation, potentially impacting the accuracy and efficiency of the quantum estimators.

Considering the diverse options for quantum simulators, feature maps, and quantum circuits, it becomes essential for researchers to provide detailed explanations of their hyperparameter choices. This entails clarifying the rationale behind selecting a specific simulator, feature map, or circuit design, as well as the associated parameters and their values. By providing such explanations, researchers can enhance the reproducibility and comparability of results, enabling the scientific community to better understand the strengths and limitations of different quantum machine learning algorithms.

Unfortunately, the current state of the field often overlooks the thorough discussion of hyperparameter choices in many studies. This omission restricts the transparency and interpretability of research outcomes and hinders the advancement of quantum machine learning. To address this issue, researchers should embrace a culture of providing comprehensive documentation regarding hyperparameter selection, sharing insights into the decision-making process, and discussing the potential implications of different choices.

By encouraging researchers to provide detailed explanations of hyperparameter choices and corresponding code, we can foster a more robust and transparent research environment in quantum machine learning. This approach enables the replication and comparison of results, promotes knowledge sharing, and ultimately contributes to the development of reliable and effective quantum machine learning algorithms. Additionally, our program code serves as introductory material, providing easy-to-use implementations and a foundation for comparing quantum machine learning (QML) and classical machine learning (CML) algorithms.

One possible direction for future research is exploring quantum ensemble classifiers and, consequently, quantum boosting classifiers, as suggested by Schuld et al. [39].This approach might help in improving the capabilities of QML algorithms and make them more competitive with state-of-the-art classical ML algorithms in terms of high accuracies.

Finally, the relatively lower performance of the employed quantum machine learning algorithms compared to, for example, the employed boosting classifiers might be attributed to Quantum Machine Learning being constrained by specific rules of quantum mechanics.

In the authors’ opinion, Quantum Machine Learning (QML) might be constrained by the unitary transformations inherent in, for example, the variational quantum circuits. These transformations are part of the unitary group $\mathrm{U}\left(n\right)$. Thus all transformations are constrained by symmetry properties. Classical machine learning models are not constrained by these limitations, meaning that, for instance, different activation functions in neural networks do not preserve certain distance metrics or probabilities when processing data. However, expanding the set of transformations of quantum machine learning and getting rid of possible constraints might improve the capabilities of quantum machine learning models such that these algorithms might be better capable of capturing the information of more complex data. However, this needs to be discussed in the context of quantum computers such that one determines what all possible transformations on a quantum computer are. This means that future research needs to consider the applicability of advanced mathematical frameworks for quantum machine learning regarding the formal requirements of quantum computers.

Further, another constraint of quantum machine learning is that it, and quantum mechanics in general, relies on Hermitian matrices, e.g., to provide real-valued eigenvalues of observables. However, breaking this constraint might be another way to broaden the capabilities of quantum machine learning to better capture complexity, e.g., by using non-Hermitian kernels in a quantum kernel estimator. Here, we want to mention the book by Moiseyev [40], which introduces non-Hermitian quantum mechanics. Further, quantum computers, in general, might provide a testing ground for non-Hermitian quantum mechanics in comparison to Hermitian quantum mechanics. However, at this point, this is rather speculative, but given that natural data is nearly always corrupted by noise and symmetries are never truly perfect in nature, breaking constraints and symmetries might be ideas to expand the capabilities of QML.

5. Conclusion

In this research, we have explored the applicability of quantum machine learning (QML) for classification tasks by examining the performance of Variational Quantum Circuit (VQC) and Quantum Kernel Estimator (QKE) algorithms. Our comparison of these quantum classifiers with classical machine learning (ML) algorithms, such as XGBoost, Ridge, Lasso, LightGBM, CatBoost, and MLP, on six benchmark datasets and artificially generated classification datasets demonstrated that QML algorithms can achieve competitive performance on certain datasets. However, they do not consistently outperform their classical ML counterparts, particularly with regard to runtime performance and accuracy. Quite the contrary, classical machine learning algorithms still demonstrate superior performance, especially in terms of increased accuracy, in most of our experiments. Further, we cannot conclude a quantum advantage even for artificial data built by data manipulations inherent to Quantum Mechanics.

As our study’s performance comparison relied on simulated quantum circuits, it is important to consider the limitations and characteristics of simulated hardware, which may affect the true potential of quantum machine learning. Given the rapid advancement of quantum technologies and hardware, these constraints may become less relevant in the future.

Quantum simulators, feature maps, and quantum circuits significantly influence quantum estimator performance; hence a detailed discussion of the chosen hyperparameters is essential. The absence of such a discussion in current research limits the interpretation and replication of experiments. Thus, we aim to encourage transparency in decision-making processes to promote a robust research environment, aiding in knowledge sharing and the creation of reliable quantum machine learning algorithms.

Despite the current limitations, this study has shed light on the potential and challenges of quantum machine learning compared to classical approaches. Thus, by providing our complete code in a GitHub repository, we hope to foster transparency, encourage further research in this field, and offer a foundation for other researchers to build upon as they explore the world of quantum machine learning. Further, the developed $SU\left(2\right)$-data creation might serve as a quantum data prototype for future experiments, and both quantum and regular machine learning algorithms can be tested for their accuracy on data sets like these.

Future research should also consider exploring quantum ensemble classifiers and quantum boosting classifiers, as well as addressing the limitations imposed by the specific rules of quantum mechanics. By breaking constraints and symmetries and expanding the set of transformations in quantum machine learning, researchers may be able to unlock its full potential.

Appendix A.1. Ridge

param_grid = {

    ’alpha’: [0.001, 0.01, 0.1, 1, 10, 100],

    ’fit_intercept’: [True, False],

    ’normalize’: [True, False],

    ’copy_X’: [True, False],

    ’max_iter’: [100, 500, 1000],

    ’tol’: [1e-4, 1e-3, 1e-2],

    ’solver’: [’auto’, ’svd’, ’cholesky’, ’lsqr’, ’sparse_cg’, ’sag’, ’saga’],

    ’random_state’: [42]

}

Appendix A.2. Lasso

param_grid = {

    ’alpha’: [0.001, 0.01, 0.1, 1, 10, 100],

    ’fit_intercept’: [True, False],

    ’normalize’: [True, False],

    ’precompute’: [True, False],

    ’copy_X’: [True, False],

    ’max_iter’: [100, 500, 1000],

    ’tol’: [1e-4, 1e-3, 1e-2],

    ’warm_start’: [True, False],

    ’positive’: [True, False],

    ’random_state’: [42],

    ’selection’: [’cyclic’, ’random’]

}

Appendix A.3. SVM

param_grid = {

    ’C’: [0.1, 1, 10, 100],

    ’kernel’: [’linear’, ’poly’, ’rbf’, ’sigmoid’],

    ’degree’: [2, 3, 4],

    ’gamma’: [’scale’, ’auto’],

    ’coef0’: [0.0, 1.0, 2.0],

    ’shrinking’: [True, False],

    ’probability’: [False],

    ’tol’: [1e-4, 1e-3, 1e-2],

    ’cache_size’: [200],

    ’class_weight’: [None, ’balanced’],

    ’verbose’: [False],

    ’max_iter’: [200, 300, 400],

    ’decision_function_shape’: [’ovr’, ’ovo’],

    ’break_ties’: [False],

    ’random_state’: [42]

}

Appendix A.4. MLP

param_grid = {

    ’hidden_layer_sizes’: [(50,), (100,), (150,)],

    ’activation’: [’relu’, ’tanh’],

    ’solver’: [’adam’, ’sgd’],

    ’alpha’: [0.0001, 0.001, 0.01],

    ’learning_rate’: [’constant’, ’invscaling’, ’adaptive’],

    ’max_iter’: [200, 300, 400]

}

Appendix A.5. XGBoost

param_grid = {

    ’max_depth’: [3, 5, 7, 10],

    ’learning_rate’: [0.01, 0.05, 0.1, 0.2],

    ’n_estimators’: [50, 100, 150, 200],

    ’subsample’: [0.5, 0.8, 1],

    ’colsample_bytree’: [0.5, 0.8, 1]

}

Appendix A.6. LightGBM

param_grid = {

    ’max_depth’: [3, 5, 7, 10],

    ’learning_rate’: [0.01, 0.05, 0.1, 0.2],

    ’n_estimators’: [50, 100, 150, 200],

    ’subsample’: [0.5, 0.8, 1],

    ’colsample_bytree’: [0.5, 0.8, 1]

}

Appendix A.7. CatBoost

param_grid = {

    ’iterations’: [50, 100, 150, 200],

    ’learning_rate’: [0.01, 0.05, 0.1, 0.2],

    ’depth’: [3, 5, 7, 10],

    ’l2_leaf_reg’: [1, 3, 5, 7, 9],

}

Appendix A.8. QKE

For this Algorithm we precomputed the Kernel-Metrix using qiskit and then performed the support vector classification via the vanilla SVM-algorithm from scikit-learn.

param_grid = {

    ’feature_map’: [PauliFeatureMap, ZFeatureMap, ZZFeatureMap],

    ’quantum_instance’: [

        QuantumInstance(Aer.get_backend(’aer_simulator’), shots=1024),

        QuantumInstance(Aer.get_backend(’qasm_simulator’), shots=1024),

        QuantumInstance(Aer.get_backend(’statevector_simulator’), shots=1024)

    ],

    ’C’ : np.logspace(-3, 3, 9),

}

Appendix A.9. VQC

param_grid = {

    ’feature_map’: [PauliFeatureMap, ZFeatureMap, ZZFeatureMap],

    ’ansatz’: [EfficientSU2, TwoLocal, RealAmplitudes],

    ’optimizer’: [

        COBYLA(maxiter=max_iter),

        SPSA(maxiter=max_iter),

        NFT(maxiter=max_iter),

    ],

    ’quantum_instance’: [

        QuantumInstance(Aer.get_backend(’aer_simulator’), shots=1024),

        QuantumInstance(Aer.get_backend(’qasm_simulator’), shots=1024),

        QuantumInstance(Aer.get_backend(’statevector_simulator’), shots=1024)

    ],

}