quantum machine learning research paper

Thank you for visiting nature.com. You are using a browser version with limited support for CSS. To obtain the best experience, we recommend you use a more up to date browser (or turn off compatibility mode in Internet Explorer). In the meantime, to ensure continued support, we are displaying the site without styles and JavaScript.

• View all journals
• Explore content
• About the journal
• Publish with us
• Sign up for alerts
• Open access
• Published: 11 May 2021

Power of data in quantum machine learning

• Hsin-Yuan Huang 1 , 2 , 3 ,
• Michael Broughton 1 ,
• Masoud Mohseni 1 ,
• Ryan Babbush 1 ,
• Sergio Boixo   ORCID: orcid.org/0000-0002-1090-7584 1 ,
• Hartmut Neven 1 &
• Jarrod R. McClean   ORCID: orcid.org/0000-0002-2809-0509 1  

Nature Communications volume  12 , Article number:  2631 ( 2021 ) Cite this article

60k Accesses

246 Citations

137 Altmetric

Metrics details

• Computer science
• Quantum information

The use of quantum computing for machine learning is among the most exciting prospective applications of quantum technologies. However, machine learning tasks where data is provided can be considerably different than commonly studied computational tasks. In this work, we show that some problems that are classically hard to compute can be easily predicted by classical machines learning from data. Using rigorous prediction error bounds as a foundation, we develop a methodology for assessing potential quantum advantage in learning tasks. The bounds are tight asymptotically and empirically predictive for a wide range of learning models. These constructions explain numerical results showing that with the help of data, classical machine learning models can be competitive with quantum models even if they are tailored to quantum problems. We then propose a projected quantum model that provides a simple and rigorous quantum speed-up for a learning problem in the fault-tolerant regime. For near-term implementations, we demonstrate a significant prediction advantage over some classical models on engineered data sets designed to demonstrate a maximal quantum advantage in one of the largest numerical tests for gate-based quantum machine learning to date, up to 30 qubits.

Similar content being viewed by others

Generalization in quantum machine learning from few training data

Understanding quantum machine learning also requires rethinking generalization

Towards provably efficient quantum algorithms for large-scale machine-learning models

Introduction.

As quantum technologies continue to rapidly advance, it becomes increasingly important to understand which applications can benefit from the power of these devices. At the same time, machine learning on classical computers has made great strides, revolutionizing applications in image recognition, text translation, and even physics applications, with more computational power leading to ever increasing performance 1 . As such, if quantum computers could accelerate machine learning, the potential for impact is enormous.

At least two paths towards quantum enhancement of machine learning have been considered. First, motivated by quantum applications in optimization 2 , 3 , 4 , the power of quantum computing could, in principle, be used to help improve the training process of existing classical models 5 , 6 , or enhance inference in graphical models 7 . This could include finding better optima in a training landscape or finding optima with fewer queries. However, without more structure known in the problem, the advantage along these lines may be limited to quadratic or small polynomial speedups 8 , 9 .

The second vein of interest is the possibility of using quantum models to generate correlations between variables that are inefficient to represent through classical computation. The recent success both theoretically and experimentally for demonstrating quantum computations beyond classical tractability can be taken as evidence that quantum computers can sample from probability distributions that are exponentially difficult to sample from classically 10 , 11 . If these distributions were to coincide with real-world distributions, this would suggest the potential for significant advantage. This is typically the type of advantage that has been sought in recent work on both quantum neural networks 12 , 13 , 14 , which seek to parameterize a distribution through some set of adjustable parameters, and quantum kernel methods 15 that use quantum computers to define a feature map that maps classical data into the quantum Hilbert space. The justification for the capability of these methods to exceed classical models often follows similar lines as refs. 10 , 11 or quantum simulation results. That is, if the model leverages a quantum circuit that is hard to sample results from classically, then there is potential for a quantum advantage.

In this work, we show quantitatively how this picture is incomplete in machine learning (ML) problems where some training data are provided. The provided data can elevate classical models to rival quantum models, even when the quantum circuits generating the data are hard to compute classically. We begin with a motivating example and complexity-theoretic argument showing how classical algorithms with data can match quantum output. Following this, we provide rigorous prediction error bounds for training classical and quantum ML methods based on kernel functions 15 , 16 , 17 , 18 , 19 , 20 , 21 , 22 , 23 , 24 to learn quantum mechanical models. We focus on kernel methods, as they not only provide provable guarantees, but are also very flexible in the functions they can learn. For example, recent advancements in theoretical machine learning show that training neural networks with large hidden layers is equivalent to training an ML model with a particular kernel, known as the neural tangent kernel 19 , 20 , 21 . Throughout, when we refer to classical ML models related to our theoretical developments, we will be referring to ML models that can be easily associated with a kernel, either explicitly as in kernel methods, or implicitly as in the neural tangent kernels. However, in the numerical section, we will also include performance comparisons to methods where direct association of a kernel is challenging, such as random forest methods. In the quantum case, we will also show how quantum ML based on kernels can be made equivalent to training an infinite depth quantum neural network.

We use our prediction error bounds to devise a flowchart for testing potential quantum prediction advantage, the separation between prediction errors of quantum and classical ML models for a fixed amount of training data. The most important test is a geometric difference between kernel functions defined by classical and quantum ML. Formally, the geometric difference is defined by the closest efficient classical ML model. In practice, one should consider the geometric difference with respect to a suite of optimized classical ML models. If the geometric difference is small, then a classical ML method is guaranteed to provide similar or better performance in prediction on the dataset, independent of the function values or labels. Hence this represents a powerful, function independent prescreening that allows one to evaluate if there is any possibility of better performance. On the other hand, if the geometry differs greatly, we show both the existence of a dataset that exhibits large prediction advantage using the quantum ML model and how one can construct it efficiently. While the tools we develop could be used to compare and construct hard classical models like hash functions, we enforce restrictions that allow us to say something about a quantum separation. In particular, the feature map will be white box, in that a quantum circuit specification is available for the ideal feature map, and that feature map can be made computationally hard to evaluate classically. A constructive example of this is a discrete log feature map, where a provable separation for our kernel is given in Supplementary Section  11 . Additionally, the minimum over classical models means that classical hash functions are reproduced formally by definition.

Moreover, application of these tools to existing models in the literature rules many of them out immediately, providing a powerful sieve for focusing development of new data encodings. Following these constructions, in numerical experiments, we find that a variety of common quantum models in the literature perform similarly or worse than classical ML on both classical and quantum datasets due to a small geometric difference. The small geometric difference is a consequence of the exponentially large Hilbert space employed by existing quantum models, where all inputs are too far apart. To circumvent the setback, we propose an improvement, which enlarges the geometric difference by projecting quantum states embedded from classical data back to approximate classical representation 25 , 26 , 27 . With the large geometric difference endowed by the projected quantum model, we are able to construct engineered datasets to demonstrate large prediction advantage over common classical ML models in numerical experiments up to 30 qubits. Despite our constructions being based on methods with associated kernels, we find empirically that the prediction advantage remains robust across tested classical methods, including those without an easily determined kernel. This opens the possibility to use a small quantum computer to generate efficiently verifiable machine learning problems that could be challenging for classical ML models.

Setup and motivating example

We begin by setting up the problems and methods of interest for classical and quantum models, and then provide a simple motivating example for studying how data can increase the power of classical models on quantum data. The focus will be a supervised learning task with a collection of N training examples {( x i ,  y i )}, where x i is the input data and y i is an associated label or value. We assume that x i are sampled independently from a data distribution \({\mathcal{D}}\) .

In our theoretical analysis, we will consider \({y}_{i}\in {\mathbb{R}}\) to be generated by some quantum model. In particular, we consider a continuous encoding unitary that maps a classical input data x i into quantum state \(\left|{x}_{i}\right\rangle ={U}_{\text{enc}}({x}_{i}){\left|0\right\rangle }^{\otimes n}\) and refer to the corresponding density matrix as ρ ( x i ). The expressive power of these embeddings have been investigated from a functional analysis point of view 28 , 29 ; however, the setting where data are provided requires special attention. The encoding unitary is followed by a unitary U QNN ( θ ). We then measure an observable O after the quantum neural network. This produces the label/value for input x i given as \({y}_{i}=f({x}_{i})=\left\langle {x}_{i}\right|{U}_{\,\text{QNN}}^{\dagger }O{U}_{\text{QNN}}\left|{x}_{i}\right\rangle \) . The quantum model considered here is also referred to as a quantum neural network (QNN) in the literature 14 , 30 . The goal is to understand when it is easy to predict the function f ( x ) by training classical/quantum machine learning models.

With notation in place, we turn to a simple motivating example to understand how the availability of data in machine learning tasks can change computational hardness. Consider data points \({\{{{\bf{x}}}_{i}\}}_{i = 1}^{N}\) that are p -dimensional classical vectors with ∣ ∣ x i ∣ ∣ 2  = 1, and use amplitude encoding 31 , 32 , 33 to encode the data into an n -qubit state \(\left|{{\bf{x}}}_{i}\right\rangle =\mathop{\sum }\nolimits_{k = 1}^{p}{x}_{i}^{k}\left|k\right\rangle \) , where \({x}_{i}^{k}\) is the individual coordinate of the vector x i . If U QNN is a time-evolution under a many-body Hamiltonian, then the function \(f({\bf{x}})=\left\langle {\bf{x}}\right|{U}_{\,\text{QNN}}^{\dagger }O{U}_{\text{QNN}}\left|{\bf{x}}\right\rangle \) is in general hard to compute classically 34 , even for a single input state. In particular, we have the following proposition showing that if a classical algorithm can compute f ( x ) efficiently, then quantum computers will be no more powerful than classical computers; see Supplementary Section  1 for a proof.

Proposition 1

If a classical algorithm without training data can compute f ( x ) efficiently for any U QNN and O , then BPP = BQP.

Nevertheless, it is incorrect to conclude that training a classical model from data to learn this evolution is hard. To see this, we write out the expectation value as

which is a quadratic function with p 2 coefficients \({B}_{kl}=\left\langle k\right|{U}_{\,\text{QNN}}^{\dagger }O{U}_{\text{QNN}}\left|l\right\rangle \) . Using the theory developed later in this work, we can show that, for any U QNN and O , training a specific classical ML model on a collection of N training examples {( x i ,  y i  =  f ( x i ))} would give rise to a prediction model h ( x i ) with

for a constant c  > 0. We refer to Supplementary Section  1 for the proof of this result. Hence, with N   ∝   p 2 / ϵ 2 training data, one can train a classical ML model to predict the function f ( x ) up to an additive prediction error ϵ . This elevation of classical models through some training samples is illustrative of the power of data. In Supplementary Section  2 , we give a rigorous complexity-theoretic argument on the computational power provided by data. A cartoon depiction of the complexity separation induced by data is provided in Fig.  1 (a).

a We cartoon the separation between problem complexities that are created by the addition of data to a problem. Classical algorithms that can learn from data define a complexity class that can solve problems beyond classical computation (BPP), but it is still expected that quantum computation can efficiently solve problems that classical ML algorithms with data cannot. A rigorous definition and proof for the separation between classical algorithms that can learn from data and BPP/BQP is given in Supplementary Section  2 . b The flowchart we develop for understanding the potential for quantum prediction advantage. N samples of data from a potentially infinite depth QNN made with encoding and function circuits U enc and U QNN are provided as input along with quantum and classical methods with associated kernels. Tests are given as functions of N to emphasize the role of data in the possibility of a prediction advantage. One can first evaluate a geometric quantity g CQ that measures the possibility of an advantageous quantum/classical prediction separation without yet considering the actual function to learn. We show how one can efficiently construct an adversarial function that saturates this limit if the test is passed, otherwise the classical approach is guaranteed to match performance for any function of the data. To subsequently consider the actual function provided, a label/function-specific test may be run using the model complexities s C and s Q . If one specifically uses the quantum kernel (QK) method, the red dashed arrows can evaluate if all possible choices of U QNN lead to an easy classical function for the chosen encoding of the data.

While this simple example makes the basic point that sufficient data can change complexity considerations, it perhaps opens more questions than it answers. For example, it uses a rather weak encoding into amplitudes and assumes one has access to an amount of data that is on par with the dimension of the model. The more interesting cases occur if we strengthen the data encoding, include modern classical ML models, and consider the number of data N much less than the dimension of the model. These more interesting cases are the ones we quantitatively answer.

Our primary interest will be ML algorithms that are much stronger than fitting a quadratic function and the input data are provided in more interesting ways than an amplitude encoding. In this work, we focus on both classical and quantum ML models based on kernel functions k ( x i ,  x j ). At a high level, a kernel function can be seen as a measure of similarity, if k ( x i ,  x j ) is large when x i and x j are close. When considered for finite input data, a kernel function may be represented as a matrix K i j  =  k ( x i ,  x j ) and the conditions required for kernel methods are satisfied when the matrix representation is Hermitian and positive semi-definite.

A given kernel function corresponds to a nonlinear feature mapping ϕ ( x ) that maps x to a possibly infinite-dimensional feature space, such that \(k({x}_{i},{x}_{j})=\phi {({x}_{i})}^{\dagger }\phi ({x}_{j})\) . This is the basis of the so-called “kernel trick” where intricate and powerful maps ϕ ( x i ) can be implemented through the evaluation of relatively simple kernel functions k . As a simple case, in the example above, using a kernel of k ( x i ,  x j ) =  ∣ 〈 x i ∣ x j 〉 ∣ 2 corresponds to a feature map \(\phi ({x}_{i})={\sum }_{kl}{x}_{i}^{k* }{x}_{i}^{l}\left|k\right\rangle \otimes \left|l\right\rangle \) which is capable of learning quadratic functions in the amplitudes. In kernel based ML algorithms, the trained model can always be written as h ( x ) =  w † ϕ ( x ) where w is a vector in the feature space defined by the kernel. For example, training a convolutional neural network with large hidden layers 19 , 35 is equivalent to using a corresponding neural tangent kernel k CNN . The feature map ϕ CNN for the kernel k CNN is a nonlinear mapping that extracts all local properties of x 35 . In quantum mechanics, similarly a kernel function can be defined using the native geometry of the quantum state space \(\left|x\right\rangle \) . For example, we can define the kernel function as 〈 x i ∣ x j 〉 or ∣ 〈 x i ∣ x j 〉 ∣ 2 . Using the output from this kernel in a method like a classical support vector machine 16 defines the quantum kernel method.

A wide class of functions can be learned with a sufficiently large amount of data by using the right kernel function k . For example, in contrast to the perhaps more natural kernel, 〈 x i ∣ x j 〉, the quantum kernel k Q ( x i ,  x j ) =  ∣ 〈 x i ∣ x j 〉 ∣ 2  = Tr( ρ ( x i ) ρ ( x j )) can learn arbitrarily deep quantum neural network U QNN that measures any observable O (shown in Supplementary Section  3 ), and the Gaussian kernel, \({k}^{\gamma }({x}_{i},{x}_{j})=\exp (-\gamma | | {x}_{i}-{x}_{j}| {| }^{2})\) with hyperparameter γ , can learn any continuous function in a compact space 36 , which includes learning any QNN. Nevertheless, the required amount of data N to achieve a small prediction error could be very large in the worst case. Although we will work with other kernels defined through a quantum space, due both to this expressive property and terminology of past work, we will refer to \({k}^{{\rm{Q}}}({x}_{i},{x}_{j})=\,\text{Tr}\,\big[\rho ({x}_{i})\rho ({x}_{j})\big]\) as the quantum kernel method throughout this work, which is also the definition given in 15 .

Testing quantum advantage

We now construct our more general framework for assessing the potential for quantum prediction advantage in a machine learning task. Beginning from a general result, we build both intuition and practical tests based on the geometry of the learning spaces. This framework is summarized in Fig.  1 .

Our foundation is a general prediction error bound for training classical/quantum ML models to predict some quantum model defined by f ( x ) = Tr( O U ρ ( x )) derived from concentration inequalities, where \({O}^{U}={U}_{\,\text{QNN}}^{\dagger }O{U}_{\text{QNN}}\) . Suppose we have obtained N training examples {( x i ,  y i  =  f ( x i ))}. After training on this data, there exists an ML algorithm that outputs h ( x ) =  w † ϕ ( x ) using kernel \(k({x}_{i},{x}_{j})={K}_{ij}=\phi {({x}_{i})}^{\dagger }\phi ({x}_{j})\) , which has a simplified prediction error bounded by

for a constant c  > 0 and N independent samples from the data distribution \({\mathcal{D}}\) . We note here that this and all subsequent bounds have a key dependence on the quantity of data N , reflecting the role of data to improve prediction performance. Due to a scaling freedom between αϕ ( x ) and w / α , we have assumed \(\mathop{\sum }\nolimits_{i = 1}^{N}\phi {({x}_{i})}^{\dagger }\phi ({x}_{i})=\,\text{Tr}\,(K)=N\) . A derivation of this result is given in Supplementary Section  4 .

Given this core prediction error bound, we now seek to understand its implications. The main quantity that determines the prediction error is

The quantity s K ( N ) is equal to the model complexity of the trained function h ( x ) =  w † ϕ ( x ), where s K ( N ) =  ∣ ∣ w ∣ ∣ 2  =  w † w after training. A smaller value of s K ( N ) implies better generalization to new data x sampled from the distribution \({\mathcal{D}}\) . Intuitively, s K ( N ) measures whether the closeness between x i ,  x j defined by the kernel function k ( x i ,  x j ) matches well with the closeness of the observable expectation for the quantum states ρ ( x i ),  ρ ( x j ), recalling that a larger kernel value indicates two points are closer. The computation of s K ( N ) can be performed efficiently on a classical computer by inverting an N  ×  N matrix K after obtaining the N values Tr( O U ρ ( x i )) by performing order N experiments on a physical quantum device. The time complexity scales at most as order N 3 . Due to the connection between w † w and the model complexity, a regularization term w † w is often added to the optimization problem during the training of h ( x ) =  w † ϕ ( x ), see e.g., refs. 16 , 37 , 38 . Regularization prevents s K ( N ) from becoming too large at the expense of not completely fitting the training data. A detailed discussion and proof under regularization is given in Supplementary Section  4 and 6 .

The prediction error upper bound can often be shown to be asymptotically tight by proving a matching lower bound. As an example, when k ( x i ,  x j ) is the quantum kernel Tr( ρ ( x i ) ρ ( x j )), we can deduce that s K ( N ) ≤ Tr( O 2 ) hence one would need a number of data N scaling as Tr( O 2 ). In Supplementary Section  8 , we give a matching lower bound showing that a scaling of Tr( O 2 ) is unavoidable if we assume a large Hilbert space dimension. This lower bound holds for any learning algorithm and not only for quantum kernel methods. The lower bound proof uses mutual information analysis and could easily extend to other kernels. This proof strategy is also employed extensively in a follow-up work 39 to devise upper and lower bounds for classical and quantum ML in learning quantum models. Furthermore, not only are the bounds asymptotically tight, in numerical experiments given in Supplementary Section  13 we find that the prediction error bound also captures the performance of other classical ML models not based on kernels where the constant factors are observed to be quite modest.

Given some set of data, if s K ( N ) is found to be small relative to N after training for a classical ML model, this quantum model f ( x ) can be predicted accurately even if f ( x ) is hard to compute classically for any given x . In order to formally evaluate the potential for quantum prediction advantage generally, one must take s K ( N ) to be the minimal over efficient classical models. However, we will be more focused on minimally attainable values over a reasonable set of classical methods with tuned hyperparameters. This prescribes an effective method for evaluating potential quantum advantage in practice, and already rules out a considerable number of examples from the literature.

From the bound, we can see that the potential advantage for one ML algorithm defined by K 1 to predict better than another ML algorithm defined by K 2 depends on the largest possible separation between \({s}_{{K}^{1}}\) and \({s}_{{K}^{2}}\) for a dataset. The separation can be characterized by defining an asymmetric geometric difference that depends on the dataset, but is independent of the function values or labels. Hence evaluating this quantity is a good first step in understanding if there is a potential for quantum advantage, as shown in Fig.  1 . This quantity is defined by

where ∣ ∣ .  ∣ ∣ ∞ is the spectral norm of the resulting matrix and we assume Tr( K 1 ) = Tr( K 2 ) =  N . One can show that \({s}_{{K}^{1}}\le {g}_{12}^{2}{s}_{{K}^{2}}\) , which implies the prediction error bound \(c\sqrt{{s}_{{K}^{1}}/N}\le c{g}_{12}\sqrt{{s}_{{K}^{2}}/N}\) . A detailed derivation is given in Supplementary Section C and an illustration of g 12 can be found in Fig.  2 . The geometric difference g ( K 1 ∣ ∣ K 2 ) can be computed on a classical computer by performing a singular value decomposition of the N  ×  N matrices K 1 and K 2 . Standard numerical analysis packages 40 provide highly efficient computation of a singular value decomposition in time at most order N 3 . Intuitively, if K 1 ( x i ,  x j ) is small/large when K 2 ( x i ,  x j ) is small/large, then the geometric difference g 12 is a small value ~1, where g 12 grows as the kernels deviate.

The letters A, B, ... represent data points { x i } in different spaces with arrows representing the similarity measure (kernel function) between data. The geometric difference g is a difference between similarity measures (arrows) in different ML models and d is an effective dimension of the dataset in the quantum Hilbert space.

To see more explicitly how the geometric difference allows one to make statements about the possibility for one ML model to make different predictions from another, consider the geometric difference g CQ  =  g ( K C ∣ ∣ K Q ) between a classical ML model with kernel k C ( x i ,  x j ) and a quantum ML model, e.g., with k Q ( x i ,  x j ) = Tr( ρ ( x i ) ρ ( x j )). If g CQ is small, because

the classical ML model will always have a similar or better model complexity s K ( N ) compared to the quantum ML model. This implies that the prediction performance for the classical ML will likely be competitive or better than the quantum ML model, and one is likely to prefer using the classical model. This is captured in the first step of our flowchart in Fig.  1 .

In contrast, if g CQ is large we show that there exists a dataset with \({s}_{{\rm{C}}}={g}_{{\rm{CQ}}}^{2}{s}_{{\rm{Q}}}\) with the quantum model exhibiting superior prediction performance. An efficient method to explicitly construct such a maximally divergent dataset is given in Supplementary Section  7 and a numerical demonstration of the stability of this separation is provided in the next section. While a formal statement about classical methods generally requires defining it overall efficient classical methods, in practice, we consider g CQ to be the minimum geometric difference among a suite of optimized classical ML models. Our engineered approach minimizes this value as a hyperparameter search to find the best classical adversary, and shows remarkable robustness across classical methods including those without an associated kernel, such as random forests 41 .

In the specific case of the quantum kernel method with \({K}_{ij}^{Q}={k}^{{\rm{Q}}}({x}_{i},{x}_{j})=\,\text{Tr}\,(\rho ({x}_{i})\rho ({x}_{j}))\) , we can gain additional insights into the model complexity s K , and sometimes make conclusions about classically learnability for all possible U QNN for the given encoding of the data. Let us define vec( X ) for a Hermitian matrix X to be a vector containing the real and imaginary part of each entry in X . In this case, we find \({s}_{Q}={\rm{vec}}{({O}^{U})}^{T}{P}_{Q}{\rm{vec}}({O}^{U})\) , where P Q is the projector onto the subspace formed by {vec( ρ ( x 1 )), …, vec( ρ ( x N ))}. We highlight

which defines the effective dimension of the quantum state space spanned by the training data. An illustration of the dimension d can be found in Fig.  1 . Because P Q is a projector and has eigenvalues 0 or 1, \({s}_{{\rm{Q}}}\le \min (d,{\rm{vec}}{({O}^{U})}^{T}{\rm{vec}}({O}^{U}))=\min (d,\,\text{Tr}\,({O}^{2}))\) assuming ∣ ∣ O ∣ ∣ ∞  ≤ 1. Hence in the case of the quantum kernel method, the prediction error bound may be written as

A detailed derivation is given in Supplementary Section A. We can also consider the approximate dimension d , where small eigenvalues in K Q are truncated, by incurring a small training error. After obtaining K Q from a quantum device, the dimension d can be computed efficiently on a classical machine by performing a singular value decomposition on the N  ×  N matrix K Q . Estimation of Tr( O 2 ) can be performed by sampling random states \(\left|\psi \right\rangle \) from a quantum 2-design, measuring O on \(\left|\psi \right\rangle \) , and performing statistical analysis on the measurement data 25 . This prediction error bound shows that a quantum kernel method can learn any U QNN when the dimension of the training set space d or the squared Frobenius norm of observable Tr( O 2 ) is much smaller than the amount of data N . In Supplementary Section  8 , we show that quantum kernel methods are optimal for learning quantum models with bounded Tr( O 2 ) as they saturate the fundamental lower bound. However, in practice, most observables, such as Pauli operators, will have exponentially large Tr( O 2 ), so the central quantity is the dimension d . Using the prediction error bound for the quantum kernel method, if both g CQ and \(\min (d,\,\text{Tr}\,({O}^{2}))\) are small, then a classical ML would also be able to learn any U QNN . In such a case, one must conclude that the given encoding of the data is classically easy, and this cannot be affected by an arbitrarily deep U QNN . This constitutes the bottom left part of our flowchart in Fig.  1 .

Ultimately, to see a prediction advantage in a particular dataset with specific function values/labels, we need a large separation between s C and s Q . This happens when the inputs x i ,  x j considered close in a quantum ML model are actually close in the target function f ( x ), but are far in classical ML. This is represented as the final test in Fig.  1 and the methodology here outlines how this result can be achieved in terms of its more essential components.

Projected quantum kernels

In addition to analyzing existing quantum models, the analysis approach introduced also provides suggestions for new quantum models with improved properties, which we now address here. For example, if we start with the original quantum kernel, when the effective dimension d is large, kernel Tr( ρ ( x i ) ρ ( x j )), which is based on a fidelity-type metric, will regard all data to be far from each other and the kernel matrix K Q will be close to identity. This results in a small geometric difference g CQ leading to classical ML models being competitive or outperforming the quantum kernel method. In Supplementary Section  9 , we present a simple quantum model that requires an exponential amount of samples to learn using the quantum kernel Tr( ρ ( x i ) ρ ( x j )), but only needs a linear number of samples to learn using a classical ML model.

To circumvent this setback, we propose a family of projected quantum kernels as a solution. These kernels work by projecting the quantum states to an approximate classical representation, e.g., using reduced physical observables or classical shadows 25 , 27 , 42 , 43 , 44 . Even if the training set space has a large dimension d  ~  N , the projection allows us to reduce to a low-dimensional classical space that can generalize better. Furthermore, by going through the exponentially large quantum Hilbert space, the projected quantum kernel can be challenging to evaluate without a quantum computer. In numerical experiments, we find that the classical projection increases rather than decreases the geometric difference with classical ML models. These constructions will be the foundation of our best performing quantum method later.

One of the simplest forms of projected quantum kernel is to measure the one-particle reduced density matrix (1-RDM) on all qubits for the encoded state, ρ k ( x i ) = Tr j ≠ k [ ρ ( x i )], then define the kernel as

This kernel defines a feature map function in the 1-RDM space that is capable of expressing arbitrary functions of powers of the 1-RDMs of the quantum state. From nonintuitive results in density functional theory, we know even one body densities can be sufficient for determining exact ground state 45 and time-dependent 46 properties of many-body systems under modest assumptions. In Supplementary Section  10 , we provide examples of other projected quantum kernels. This includes an efficient method for computing a kernel function that contains all orders of RDMs using local randomized measurements and the formalism of classical shadows 25 . The classical shadow formalism allows efficient construction of RDMs from very few measurements. In Supplementary Section  11 , we show that projected versions of quantum kernels lead to a simple and rigorous quantum speed-up in a recently proposed learning problem based on discrete logarithms 24 .

Numerical studies

We now provide numerical evidence up to 30 qubits that supports our theory on the relation between the dimension d , the geometric difference g , and the prediction performance. Using the projected quantum kernel, the geometric difference g is much larger and we see the strongest empirical advantage of a scalable quantum model on quantum datasets to date. These are the largest combined simulation and analysis in digital quantum machine learning that we are aware of, and make use of the TensorFlow and TensorFlow-Quantum package 47 , reaching a peak throughput of up to 1.1 quadrillion floating point operations per second (petaflop/s). Trends of ~300 teraflop/s for quantum simulation and 800 teraflop/s for classical analysis were observed up to the maximum experiment size with the overall floating point operations across all experiments totalling ~2 quintillion (exaflop).

In order to mimic a data distribution that pertains to real-world data, we conduct our experiments around the fashion-MNIST dataset 48 , which is an image classification for distinguishing clothing items, and is more challenging than the original digit-based MNIST source 49 . We preprocess the data using principal component analysis 50 to transform each image into an n -dimensional vector. The same data are provided to the quantum and classical models, where in the classical case the data is the n -dimensional input vector, and the quantum case uses a given circuit to embed the n -dimensional vector into the space of n qubits. For quantum embeddings, we explore three options, E1 is a separable rotation circuit 32 , 51 , 52 , E2 is an IQP-type embedding circuit 15 , and E3 is a Hamiltonian evolution circuit, with explicit constructions in Supplementary Section  12 .

For the classical ML task (C), the goal is to correctly identify the images as shirts or dresses from the original dataset. For the quantum ML tasks, we use the same fashion-MINST source data and embeddings as above, but take as function values the expectation value of a local observable that has been evolved under a quantum neural network resembling the Trotter evolution of 1D-Heisenberg model with random couplings. In these cases, the embedding is taken as part of the ground truth, so the resulting function will be different depending on the quantum embedding. For these ML tasks, we compare against the best performing model from a list of standard classical ML algorithms with properly tuned hyperparameters (see Supplementary Section  12 for details).

In Fig.  3 , we give a comparison between the prediction performance of classical and quantum ML models. One can see that not only do classical ML models perform best on the original classical dataset, the prediction performance for the classical methods on the quantum datasets is also very competitive and can even outperform existing quantum ML models despite the quantum ML models having access to the training embedding while the classical methods do not. The performance of the classical ML model is especially strong on Dataset (Q, E1) and Dataset (Q, E2). This elevation of the classical performance is evidence of the power of data. Moreover, this intriguing behavior and the lack of quantum advantage may be explained by considering the effective dimension d and the geometric difference g following our theoretical constructions. From Fig.  3 a, we can see that the dimension d of the original quantum state space grows rather quickly, and the geometric difference g becomes small as the dimension becomes too large ( d   ∝   N ) for the standard quantum kernel. The saturation of the dimension coincides with the decreasing and statistical fluctuations in performance seen in Fig.  4 . Moreover, given poor ML performance a natural instinct is to throw more resources at the problem, e.g., more qubits, but as demonstrated here, doing this for naïve quantum kernel methods is likely to lead to tiny inner products and even worse performance. In contrast, the projected quantum space has a low dimension even when d grows, and yields a higher geometric difference g for all embeddings and system sizes. Our methodology predicts that, when g is small, classical ML model will be competitive or outperform the quantum ML model. This is verified in Fig.  3 b for both the original and projected quantum kernel, where a small geometric difference g leads to a very good performance of classical ML models and no large quantum advantage can be seen. Only when the geometric difference g is large (projected kernel method with embedding E3) can we see some mild advantage over the best classical method. This result holds disregarding any detail of the quantum evolution we are trying to learn, even for ones that are hard to simulate classically.

The shaded regions are the standard deviation over 10 independent runs and n is the number of qubits in the quantum encoding and dimension of the input for the classical encoding. a The approximate dimension d and the geometric difference g with classical ML models for quantum kernel (Q) and projected quantum kernel (PQ) under different embeddings and system sizes n . b Prediction error (lower is better) of the quantum kernel method (Q), projected quantum kernel method (PQ), and classical ML models on classical (C) and quantum (Q) datasets with number of data N  = 600. As d grows too large, the geometric difference g for quantum kernel becomes small. We see that small geometric difference g always results in classical ML being competitive or outperforming the quantum ML model. When g is large, there is a potential for improvement over classical ML. For example, projected quantum kernel improves upon the best classical ML in Dataset (Q, E3).

A label function is engineered to match the geometric difference g (C ∣ ∣ PQ) between projected quantum kernel and classical approaches, demonstrating a significant gap between quantum and the best classical models up to 30 qubits when g is large. We consider the best performing classical ML models among Gaussian SVM, linear SVM, Adaboost, random forest, neural networks, and gradient boosting. We only report the accuracy of the quantum kernel method up to system size n  = 28 due to the high simulation cost and the inferior performance.

In order to push the limits of separation between quantum and classical approaches in a learning setting, we now consider a set of engineered datasets with function values designed to saturate the geometric inequality \({s}_{{\rm{C}}}\le g{({K}^{{\rm{C}}}| | {K}^{{\rm{PQ}}})}^{2}{s}_{{\rm{PQ}}}\) between classical ML models with associated kernels and the projected quantum kernel method. In particular, we design the dataset such that s PQ  = 1 and \({s}_{{\rm{C}}}=g{({K}^{{\rm{C}}}| | {K}^{{\rm{PQ}}})}^{2}\) . Recall from Eq. ( 3 ), this dataset will hence show the largest separation in the prediction error bound \(\sqrt{s(N)/N}\) . The engineered dataset is constructed via a simple eigenvalue problem with the exact procedure described in Supplementary Section  7 and the results are shown in Fig.  4 . As the quantum nature of the encoding increases from E1 to E3, corresponding to increasing g , the performance of both the best classical methods and the original quantum kernel decline precipitously. The advantage of the projected quantum kernel closely follows the geometric difference g and reaches more than 20% for large sizes. Despite the optimization of g only being possible for classical methods with an associated kernel, the performance advantage remains stable across other common classical methods. Note that we also constructed engineered datasets saturating the geometric inequality between classical ML and the original quantum kernel, but the small geometric difference g presented no empirical advantage at large system size (see Supplementary Section  13 ).

In keeping with our arguments about the role of data, when we increase the number of training data N , all methods improve, and the advantage will gradually diminish. While this dataset is engineered, it shows the strongest empirical separation on the largest system size to date. We conjecture that this procedure could be used with a quantum computer to create challenging datasets that are easy to learn with a quantum device, hard to learn classically, while still being easy to verify classically given the correct labels. Moreover, the size of the margin implies that this separation may even persist under moderate amounts of noise in a quantum device.

The use of quantum computing in machine learning remains an exciting prospect, but quantifying quantum advantage for such applications has some subtle issues that one must approach carefully. Here, we constructed a foundation for understanding opportunities for quantum advantage in a learning setting. We showed quantitatively how classical ML algorithms with data can become computationally more powerful, and a prediction advantage for quantum models is not guaranteed even if the data come from a quantum process that is challenging to independently simulate. Motivated by these tests, we introduced projected quantum kernels. On engineered datasets, projected quantum kernels outperform all tested classical models in prediction error. To the authors’ knowledge, this is the first empirical demonstration of such a large separation between quantum and classical ML models.

This work suggests a simple guidebook for generating ML problems which give a large separation between quantum and classical models, even at a modest number of qubits. The size of this separation and trend up to 30 qubits suggests the existence of learning tasks that may be easy to verify, but hard to model classically, requiring just a modest number of qubits and allowing for device noise. Claims of true advantage in a quantum machine learning setting require not only benchmarking classical machine learning models, but also classical approximations of quantum models. Additional work will be needed to identify embeddings that satisfy the sometimes conflicting requirements of being hard to approximate classically and exhibiting meaningful signal on local observables for very large numbers of qubits. Further research will be required to find use cases on datasets closer to practical interest and evaluate potential claims of advantage, but we believe the tools developed in this work will help to pave the way for this exciting frontier.

Data availability

All other data that support the plots within this paper and other findings of this study are available upon reasonable request.  Source data are provided with this paper.

Code availability

A tutorial for reproducing smaller numerical experiments is available at https://www.tensorflow.org/quantum/tutorials/quantum_data .

Halevy, A., Norvig, P. & Pereira, F. The unreasonable effectiveness of data. IEEE Intell. Syst. 24 , 8 (2009).

Article   Google Scholar  

Grover, L. K. A fast quantum mechanical algorithm for database search. in Proc. twenty-eighth annual ACM symposium on Theory of computing (1996).

Durr, C. & Hoyer, P. A quantum algorithm for finding the minimum . https://arxiv.org/abs/quant-ph/9607014 (1996).

Farhi, E. et al. A quantum adiabatic evolution algorithm applied to random instances of an np-complete problem. Science 292 , 472 (2001).

Article   ADS   MathSciNet   CAS   Google Scholar  

Neven, H., Denchev, V. S., Rose, G. & Macready, W. G. Training a large scale classifier with the quantum adiabatic algorithm . https://arxiv.org/abs/0912.0779 (2009).

Rebentrost, P., Mohseni, M. & Lloyd, S. Quantum support vector machine for big data classification. Phys. Rev. Lett. 113 , 130503 (2014).

Article   ADS   Google Scholar  

Leifer, M. S. & Poulin, D. Quantum graphical models and belief propagation. Ann. Phys. 323 , 1899 (2008).

Aaronson, S. & Ambainis, A. The need for structure in quantum speedups . https://arxiv.org/abs/0911.0996 (2009).

McClean, J. R. et al. Low depth mechanisms for quantum optimization . https://arxiv.org/abs/2008.08615 (2020).

Boixo, S. et al. Characterizing quantum supremacy in near-term devices. Nat. Phys. 14 , 595 (2018).

Article   CAS   Google Scholar  

Arute, F. et al. Quantum supremacy using a programmable superconducting processor. Nature 574 , 505 (2019).

ADS   CAS   PubMed   Google Scholar  

Peruzzo, A. et al. A variational eigenvalue solver on a photonic quantum processor. Nat. Commun. 5 , 4213 (2014).

Article   ADS   CAS   Google Scholar  

McClean, J. R., Romero, J., Babbush, R. & Aspuru-Guzik, A. The theory of variational hybrid quantum-classical algorithms. N. J. Phys. 18 , 023023 (2016).

Farhi, E. & Neven, H. Classification with quantum neural networks on near term processors. arXiv preprint arXiv:1802.06002 https://arxiv.org/abs/1802.06002 (2018).

Havlíček, V. et al. Supervised learning with quantum-enhanced feature spaces. Nature 567 , 209 (2019).

Cortes, C. & Vapnik, V. Support-vector networks. Mach. Learn. 20 , 273 (1995).

MATH   Google Scholar  

Schölkopf, B. et al. Learning with kernels: support vector machines, regularization, optimization, and beyond. https://mitpress.mit.edu/books/learning-kernels (2002).

Mohri, M., Rostamizadeh, A. & Talwalkar, A. Foundations of machine learning. https://mitpress.mit.edu/books/foundations-machine-learning-second-edition (2018).

Jacot, A., Gabriel, F. & Hongler, C. Neural tangent kernel: Convergence and generalization in neural networks. NIPS’18: Proceedings of the 32nd International Conference on Neural Information Processing Systems https://dl.acm.org/doi/abs/10.5555/3327757.3327948 pp. 8580–8589 (2018).

Novak, R. et al. Neural tangents: Fast and easy infinite neural networks in python. arXiv preprint arXiv:1912.02803 https://openreview.net/pdf?id=SklD9yrFPS (2019).

Arora, S. et al. On exact computation with an infinitely wide neural net. in Advances in Neural Information Processing Systems (2019).

Blank, C., Park, D. K., Rhee, J.-K. K. & Petruccione, F. Quantum classifier with tailored quantum kernel. npj Quantum Inf. 6 , 1 (2020).

Bartkiewicz, K. Experimental kernel-based quantum machine learning in finite feature space. Sci. Rep. 10 , 1 (2020).

Liu, Y., Arunachalam, S. & Temme, K. A rigorous and robust quantum speed-up in supervised machine learning. arXiv preprint arXiv:2010.02174 https://arxiv.org/abs/2010.02174 (2020).

Huang, H.-Y., Kueng, R. & Preskill, J. Predicting many properties of a quantum system from very few measurements. Nat. Phys . https://doi.org/10.1038/s41567-020-0932-7 (2020).

Cotler, J. & Wilczek, F. Quantum overlapping tomography. Phys. Rev. Lett. 124 , 100401 (2020).

Paini, M. and Kalev, A. An approximate description of quantum states. arXiv preprint arXiv:1910.10543 https://arxiv.org/abs/1910.10543 (2019).

Lloyd, S., Schuld, M., Ijaz, A., Izaac, J. & Killoran, N. Quantum embeddings for machine learning. arXiv preprint arXiv:2001.03622 https://arxiv.org/abs/2008.08605 (2020).

Schuld, M., Sweke, R. & Meyer, J. J. The effect of data encoding on the expressive power of variational quantum machine learning models. Phys. Rev. A 103 , 032430 (2021).

McClean, J. R., Boixo, S., Smelyanskiy, V. N., Babbush, R. & Neven, H. Barren plateaus in quantum neural network training landscapes. Nat. Commun. 9 , 1 (2018).

Grant, E., Wossnig, L., Ostaszewski, M. & Benedetti, M. An initialization strategy for addressing barren plateaus in parametrized quantum circuits. Quantum 3 , 214 (2019).

Schuld, M., Bocharov, A., Svore, K. M. & Wiebe, N. Circuit-centric quantum classifiers. Phys. Rev. A 101 , 032308 (2020b).

LaRose, R. & Coyle, B. Robust data encodings for quantum classifiers. Phys. Rev. A 102 , 032420 (2020).

Harrow, A. W. & Montanaro, A. Quantum computational supremacy. Nature 549 , 203 (2017).

Li, Z. et al. Enhanced convolutional neural tangent kernels. arXiv preprint arXiv:1911.00809 https://arxiv.org/abs/1911.00809 (2019).

Micchelli, C. A., Xu, Y. & Zhang, H. Universal kernels. J. Mach. Learn. Res. 7 , 2651 (2006).

MathSciNet   MATH   Google Scholar  

Krogh, A. & Hertz, J. A. A simple weight decay can improve generalization . Adv. Neural Inf. Process. Syst. 950–957 (1992).

Suykens, J. A. & Vandewalle, J. Least squares support vector machine classifiers. Neural Process. Lett. 9 , 293 (1999).

Huang, H.-Y., Kueng, R. & Preskill, J. Information-theoretic bounds on quantum advantage in machine learning. arXiv preprint arXiv:2101.02464 https://arxiv.org/abs/2101.02464 (2021).

Anderson, E. et al. LAPACK Users’ Guide , 3rd edn. (Society for Industrial and Applied Mathematics, 1999).

Breiman, L. Random forests. Mach. Learn. 45 , 5 (2001).

Gosset, D. & Smolin, J. A compressed classical description of quantum states. arXiv preprint arXiv:1801.05721 https://arxiv.org/abs/1801.05721 (2018).

Aaronson, S. Shadow tomography of quantum states. SIAM J. Comput. https://dl.acm.org/doi/abs/10.1145/3188745.3188802 (2020).

Aaronson, S. and Rothblum, G. N. Gentle measurement of quantum states and differential privacy. in Proc. 51st Annual ACM SIGACT Symposium on Theory of Computing (2019).

Hohenberg, P. & Kohn, W. Inhomogeneous electron gas. Phys. Rev. 136 , B864 (1964).

Article   ADS   MathSciNet   Google Scholar  

Runge, E. & Gross, E. K. Density-functional theory for time-dependent systems. Phys. Rev. Lett. 52 , 997 (1984).

Broughton, M. et al. Tensorflow quantum: A software framework for quantum machine learning. arXiv preprint arXiv:2003.02989 https://arxiv.org/abs/2003.02989 (2020).

Xiao, H., Rasul, K. & Vollgraf, R. Fashion-mnist: a novel image dataset for benchmarking machine learning algorithms. arXiv preprint arXiv:1708.07747 https://arxiv.org/abs/1708.07747 (2017).

LeCun, Y., Cortes, C. & Burges, C. Mnist handwritten digit database . http://yann.lecun.com/exdb/mnist (2010).

Jolliffe, I. T. in Principal component analysis 129–155 (Springer, 1986).

Schuld, M. & Killoran, N. Quantum machine learning in feature hilbert spaces. Phys. Rev. Lett. 122 , 040504 (2019).

Skolik, A., McClean, J. R., Mohseni, M., van der Smagt, P. & Leib, M. Layerwise learning for quantum neural networks. Quantum Machine Intelligence 3 , 5 (2021).

Download references

Acknowledgements

We want to thank Richard Kueng, John Platt, John Preskill, Thomas Vidick, Nathan Wiebe, and Chun-Ju Wu for valuable inputs and inspiring discussions. We thank Bálint Pató for crucial contributions in setting up simulations.

Author information

Authors and affiliations.

Google Quantum AI, Venice, CA, USA

Hsin-Yuan Huang, Michael Broughton, Masoud Mohseni, Ryan Babbush, Sergio Boixo, Hartmut Neven & Jarrod R. McClean

Institute for Quantum Information and Matter, Caltech, Pasadena, CA, USA

Hsin-Yuan Huang

Department of Computing and Mathematical Sciences, Caltech, Pasadena, CA, USA

You can also search for this author in PubMed   Google Scholar

Contributions

H.H. and J.M. developed the theoretical aspects of this work. H.H. and M.B. conducted the numerical experiments and wrote the open source code. H.H., M.M., R.B., S.B., H.N., and J.M. contributed to technical discussions and writing of the manuscript.

Corresponding author

Correspondence to Jarrod R. McClean .

Ethics declarations

Competing interests.

The authors declare no competing interests.

Additional information

Peer review information   Nature Communications thanks Nana Liu and the other, anonymous, reviewer(s) for their contribution to the peer review of this work.

Publisher’s note Springer Nature remains neutral with regard to jurisdictional claims in published maps and institutional affiliations.

Supplementary information

Supplementary information, source data, source data, rights and permissions.

Open Access This article is licensed under a Creative Commons Attribution 4.0 International License, which permits use, sharing, adaptation, distribution and reproduction in any medium or format, as long as you give appropriate credit to the original author(s) and the source, provide a link to the Creative Commons license, and indicate if changes were made. The images or other third party material in this article are included in the article’s Creative Commons license, unless indicated otherwise in a credit line to the material. If material is not included in the article’s Creative Commons license and your intended use is not permitted by statutory regulation or exceeds the permitted use, you will need to obtain permission directly from the copyright holder. To view a copy of this license, visit http://creativecommons.org/licenses/by/4.0/ .

Reprints and permissions

About this article

Cite this article.

Huang, HY., Broughton, M., Mohseni, M. et al. Power of data in quantum machine learning. Nat Commun 12 , 2631 (2021). https://doi.org/10.1038/s41467-021-22539-9

Download citation

Received : 18 November 2020

Accepted : 16 March 2021

Published : 11 May 2021

DOI : https://doi.org/10.1038/s41467-021-22539-9

Share this article

Anyone you share the following link with will be able to read this content:

Sorry, a shareable link is not currently available for this article.

Provided by the Springer Nature SharedIt content-sharing initiative

This article is cited by

Quantum-parallel vectorized data encodings and computations on trapped-ion and transmon qpus.

• Jan Balewski
• Mercy G. Amankwah

Scientific Reports (2024)

Drug design on quantum computers

• Raffaele Santagati
• Alan Aspuru-Guzik
• Clemens Utschig-Utschig

Nature Physics (2024)

Covariant quantum kernels for data with group structure

• Jennifer R. Glick
• Tanvi P. Gujarati
• Kristan Temme
• Minzhao Liu
• Liang Jiang

Nature Communications (2024)

Recurrent quantum embedding neural network and its application in vulnerability detection

• Zhihui Song

By submitting a comment you agree to abide by our Terms and Community Guidelines . If you find something abusive or that does not comply with our terms or guidelines please flag it as inappropriate.

Quick links

• Explore articles by subject
• Guide to authors
• Editorial policies

Sign up for the Nature Briefing: AI and Robotics newsletter — what matters in AI and robotics research, free to your inbox weekly.

Information

• Author Services

Initiatives

You are accessing a machine-readable page. In order to be human-readable, please install an RSS reader.

All articles published by MDPI are made immediately available worldwide under an open access license. No special permission is required to reuse all or part of the article published by MDPI, including figures and tables. For articles published under an open access Creative Common CC BY license, any part of the article may be reused without permission provided that the original article is clearly cited. For more information, please refer to https://www.mdpi.com/openaccess .

Feature papers represent the most advanced research with significant potential for high impact in the field. A Feature Paper should be a substantial original Article that involves several techniques or approaches, provides an outlook for future research directions and describes possible research applications.

Feature papers are submitted upon individual invitation or recommendation by the scientific editors and must receive positive feedback from the reviewers.

Editor’s Choice articles are based on recommendations by the scientific editors of MDPI journals from around the world. Editors select a small number of articles recently published in the journal that they believe will be particularly interesting to readers, or important in the respective research area. The aim is to provide a snapshot of some of the most exciting work published in the various research areas of the journal.

Original Submission Date Received: .

• Active Journals
• Find a Journal
• Proceedings Series
• For Authors
• For Reviewers
• For Editors
• For Librarians
• For Publishers
• For Societies
• For Conference Organizers
• Open Access Policy
• Institutional Open Access Program
• Special Issues Guidelines
• Editorial Process
• Research and Publication Ethics
• Article Processing Charges
• Testimonials
• Preprints.org
• SciProfiles
• Encyclopedia

Article Menu

• Subscribe SciFeed
• Recommended Articles
• PubMed/Medline
• Google Scholar
• on Google Scholar
• Table of Contents

Find support for a specific problem in the support section of our website.

Please let us know what you think of our products and services.

Visit our dedicated information section to learn more about MDPI.

JSmol Viewer

Quantum machine learning: a review and case studies.

1. Introduction

2. background, 2.1. dirac (bra-ket) notation.

• Ket: | a 〉 = a 1 a 2 . (1)
• Bra: 〈 b | = | b 〉 * = b 1 b 2 * = b 1 * b 2 * . (2) Note that the complex conjugate of any complex number can be generated by inverting the sign of its imaginary component—for example, the complex conjugate of b = a + i × d is b * = a − i × d .
• Bra-Ket: Inner product 〈 b | a 〉 = a 1 b 1 * + a 2 b 2 * = 〈 a | b 〉 * . (3)
• Ket-Bra: Outer product | a 〉 〈 b | = a 1 b 1 * a 1 b 2 * a 2 b 1 * a 2 b 2 * . (4)
• X-Basis: | + 〉 : = 1 2 | 0 〉 + | 1 〉 , | − 〉 : = 1 2 | 0 〉 − | 1 〉
• Y-Basis: | + i 〉 : = 1 2 | 0 〉 + i | 1 〉 , | − i 〉 : = 1 2 | 0 〉 − i | 1 〉

2.3. Quantum Circuit

2.4. quantum gates, 2.4.1. single qubit gates.

• Pauli-X Gate: Is the quantum equivalent of the NOT gate used in traditional computers, generally termed as the bit flip operator or x σ x : X : = 0 1 1 0 . When we apply X to | 0 〉 , we obtain 0 1 1 0 1 0 = 0 1 = | 1 〉 . As we can see, this gate flips the amplitudes of the | 0 〉 and | 1 〉 states. In a quantum circuit, the symbol in Figure 2 a represents the Pauli-X gate.
• Pauli-Y Gate: Is commonly abbreviated as σ y , which transforms the state vector throughout the whole y -axis: Y : = 0 − i i 0 . Consequently, when it is applied to the | 1 〉 state, we obtain 0 − i i 0 0 1 = − i 0 = − i | 0 〉 . In Figure 2 b, the circuit design for the Y operator is displayed.
• Pauli-Z Gate: The Z operator, also known as the phase flip operator, used to perform a 180 ∘ rotation of the state vector around the z -axis. Z : = 1 0 0 − 1 . By applying the Pauli-Z gate to the computational basis state, we obtain the result shown below: Z | u 〉 = ( − 1 ) u | u 〉 . For the particular case u = 0 , we present it in matrix form: 1 0 0 − 1 1 0 = 1 0 = ( − 1 ) 0 | 0 〉 = | 0 〉 . We have in the case where u = 1 , 1 0 0 − 1 0 1 = 0 − 1 = ( − 1 ) 1 | 1 〉 = − | 1 〉 . The Pauli-Z gate’s circuit diagram is shown in Figure 2 c.
• Phase shift gates: Consists of a set of single-qubit gates which convert the basis states | 0 〉 ↦ | 0 〉 and | 1 〉 ↦ e i φ | 1 〉 . The matrix below represents the phase shift gate: P ( φ ) = 0 1 1 e i φ , where φ denotes the phase shift over a period of 2π. Typical instances include the Pauli-Z gate where φ = π , T gate where φ = π 4 , and S gate where φ = π 2 .
• Hadamard Gate: This quantum operator is essential for quantum computing because it allows the qubit to transform from one computational basis state to a superposition. H : = 1 2 1 1 1 − 1 . When Hadamard gate is applied to the state | 0 〉 , we obtain 1 2 1 1 1 − 1 1 0 = 1 2 1 1 = | 0 〉 + | 1 〉 2 , and to state | 1 〉 , we obtain 1 2 1 1 1 − 1 0 1 = 1 2 1 − 1 = | 0 〉 − | 1 〉 2 . As can be seen, the Hadamard gate projects a computational basis state into the superposition of two states.

2.4.2. Multi Qubit States and Gates

2.5. representation of qubit states.

• | 0 〉 : θ = 0 , ϕ arbitrary → r → = ( 0 , 0 , 1 ) ;
• | 1 〉 : θ = π , ϕ arbitrary → r → = ( 0 , 0 , − 1 ) ;
• | + 〉 : θ = π / 2 , ϕ = 0 → r → = ( 1 , 0 , 0 ) ;
• | − 〉 : θ = π / 2 , ϕ = π → r → = ( − 1 , 0 , 0 ) ;
• | + i 〉 : θ = π / 2 , ϕ = π / 2 → r → = ( 0 , 1 , 0 ) ;
• | − i 〉 : θ = π / 2 , ϕ = 3 π / 2 → r → = ( 0 , − 1 , 0 ) .
• For a single qubit as shown in Figure 4 a: - The south pole represents the state | 1 〉 ; - The north pole represents the state | 0 〉 ; - The size of the blobs is related to the likelihood that the relevant state will be measured; - The color indicates the relative phase compared to the state | 0 〉 .
• For n qubits: In Figure 4 b, we plot all states as equally distributed points on sphere with 0 ⊗ n on the north pole, 1 ⊗ n on the south pole, and all other state are aligned on parallels, such as the number of “1”s on each latitude is constant and increasing from north to south.

2.6. Entanglement

2.7. quantum computer.

• Quantum registers are just a collections of qubits. In November 2022, the benchmarked record was 433 qubits, announced by IBM. Quantum registers store the information manipulated in the computer and exploit the principle of superposition allowing a large number of values to coexist in these registers and to operate on them simultaneously;
• Quantum gates are physical systems acting on the qubits of the quantum registers, to initialize them and to perform computational operations on them. These gates are applied in an iterative way according to the algorithms to be executed;
• At the conclusion of the sequential execution of quantum gates, the measurement interface permits the retrieval of the calculations’ results. Typically, this cycle of setup, computation, and measurement is repeated several times to assess the outcome. We then obtain an average value between 0 and 1 for each qubit of the quantum computer registers. The values received by the physical reading devices are therefore translated into digital values and sent to the traditional computer, which controls the whole system and permits the interpretation of the data. In common cases, such as at D-Wave or IBM, which are the giants of quantum computers building, the calculation is repeated at least 1024 times in the quantum computer;
• Quantum chipset includes quantum registers, quantum gates and measurement devices when it comes to superconducting qubits. Current chipsets are not very large. They are the size of a full-frame photo sensor or double size for the largest of them. The size of the latest powerful quantum chip called the 433-qubit Osprey, around the size of a quarter;
• Refrigerated enclosure generally holds the inside of the computer at temperatures near absolute zero. It contains part of the control electronics and the quantum chipset to avoid generating disturbances that prevent the qubits from working, especially at the level of their entanglement and coherence, and to reduce the noise of their operation;
• Electronic writing and reading in the refrigerated enclosure, control the physical devices needed to initialize, update, and read the state of qubits.

2.8. Quantum Algorithms

• Polynomial time (P): Are issues solvable in a polynomial amount of time. In other terms, a traditional computer is capable of resolving the issue in a reasonable time;
• Non-deterministic Polynomial time (NP): Is a collection of decision issues that a nondeterministic Turing machine might solve in polynomial time. P is an NP subset;
• NP-Complete: X is considered to be NP-Complete only if the requirements here are met: ( i ) X is in NP, and ( i i ) in polynomial time, all NP problems are reducible to X. We assert that X is NP-hard if only ( i i ) is true and not necessarily ( i ) ;
• Polynomial Space (PSPACE): This category is concerned with memory resources instead of time. PSPACE is a category of decision issues that can be solved by an algorithm whose total space utilization is always polynomially restricted by the instance size;
• Bounded-error Probabilistic Polynomial time (BPP): Is a collection of decision issues which may be handled in polynomial time using a probabilistic Turing computer with such a maximum error probability equal to 1/3;
• Bounded-error Quantum Polynomial time (BQP): A decision issue is BQP, if it has a polynomial time solution and has a high accuracy probability. BQP is the basic complexity category of problems which quantum computers may effectively solve. It corresponds to the classical BPP class on the quantum level;
• Exact Quantum Polynomial time (EQP or QP): Is a type of decision issue that a quantum computer can handle in polynomial time with probability 1. This is the quantum counterpart of the P complexity class.

3. Quantum Machine Learning

3.1. quantum encoding, 3.1.1. basis encoding, 3.1.2. amplitude encoding, 3.1.3. qsample encoding, 3.2. essential quantum routines for qml, 3.2.1. hhl algorithm, 3.2.2. grover’s algorithm, 3.2.3. quantum phase estimation, 3.2.4. variational quantum circuit, 3.3. qml algorithms, 3.3.1. quantum support vector machines, 3.3.2. quantum least square svm.

• Quantum random access memory (QRAM) data translation: Preparing the collected data as input into the quantum device for computation is among the difficult tasks in QML. QRAM aids in transforming a collection of classical data into its quantum counterpart. QRAM requires O ( l o g 2 d ) steps to retrieve data from storage in order to reconstruct a state, with d representing the feature vector’s dimension;
• Computation of the kernel matrix: The kernel matrix is mostly determined by the examination of the dot product. Therefore, if we obtain speedup benefits of the dot product performance in the quantum approach, this will result in an overall speedup increase in the computation of the kernel matrix. With the use of quantum characteristics, the authors of [ 5 ] provide a quicker method for calculating dot products. A quantum paradigm is also used for the computation of the normalized kernel matrix inversion K − 1 . As previously said, QRAM requires only O ( l o g 2 d ) steps to request for recreating a state, hence a simple dot product using QRAM requires O ( ϵ − 1 l o g 2 d ) steps, where ϵ represents a desired level of accuracy;
• Least square formulation: The quantum implementation of the exponentially faster eigenvector performance makes the speedup increase conceivable during the training phase in matrix inversion method and non-sparse density matrices [ 5 ].

3.3.3. Quantum Linear Regression

3.3.4. quantum k-means clustering, 3.3.5. quantum principal component analysis, 4. ml vs. qml benchmarks, 4.1. variational quantum classifier.

• State preparation: To be able to encode classical data into quantum states, we use particular operations to help us work with data in a quantum circuit. As mentioned earlier, quantum encoding is one these methods that consists of representing classical data in the form of a quantum state in Hilbert space employing a quantum feature map. Recall that a feature map is a mathematical mapping that allows us to integrate our data into higher dimensional spaces, such as quantum states in our case. It is similar to a variational circuit in which the parameters are determined by the input data. It is essential to emphasize that a variational circuit depends on parameters that can be optimized using classical methods;
• The model circuit: The next step is the model circuit, or the classifier in precise terms. φ ′ is generated using a parameterized unitary operator U θ applied to the feature vector noted as φ ( x ) which became a vector of a quantum state in an n-qubit system (in the Hilbert space ). The model uses a circuit that is composed of gates which change the state of the input and are built on unitary processes, and they depend on external factors that can be adjusted. U θ translates φ ( x ) into another vector φ ′ with a prepared state | φ ( x ) 〉 in the model circuit. U θ is comprised of a series of unitary gates;
• Measurement: We take measurements in order to obtain information from a quantum system. Although a quantum system has an infinite number of potential states, we can only recover a limited amount of information from a quantum measurement. Notice that the number of qubits is equal to the amount of results;
• Post-process: Finally, the results were post-processed including a learnable bias parameter and a step function to translate the result to the outcome 0 or 1.

4.1.1. Implementation

• Dataset: Our classification data sets made up of three sorts of irises (Setosa, Versicolour, and Virginica), and containing four features that are Sepal Length, Sepal Width, Petal Length and Petal Width. In our implementation, we used the two first classes:
• Implemented models: - VQC: The Variational Quantum Classifiers commonly define a “layer”, whose fundamental circuit design is replicated to create the variational circuit. Our circuit layer is composed of a random rotation upon each qubit, and also a CNOT gate that entangles each qubit with its neighbor. The classical data were encoded to amplitude vectors via amplitude encoding; - SVC: A support vector classifier (SVC) implemented by the sklearn Python library; - Decision Tree: Is a non-parametric learning algorithm which anticipates the target variable through learning decision rules; - Naive Bayes: Naive Bayes classifiers utilize Bayes theory with the assumption of conditional independence in between each pair of features;
• Experimental Environment: We use the Jupyter Notebook and PennyLane [ 80 ] (A cross-platform Python framework for discrete programming of quantum computing) for developing all the codes and executing them on IBM Quantum simulators [ 81 ]. We implemented three classical Scikitlearn [ 82 ] algorithms to accomplish the same classification task on a conventional computer in order to compare their performance with that of the VQC. We also used the end value of the cost function and the test accuracy as metrics for evaluating the implemented algorithms.

4.1.2. Results

4.2. svm vs. qsvm, 4.2.1. implementation.

• Breast cancer dataset: The Wisconsin Diagnostic Breast Cancer dataset (WDBC) of UCI machine learning repository is a classification dataset that includes breast cancer case metrics. There are two categories: benign and malignant. This dataset contains information on 31 characteristics that define a tumor, among which are: average radius, mean perimeter, mean texture, etc., and a total of 569 records and 31 features;
• Principal Component Analysis: The existing quantum computers are yet to attain full potential as their functions are constrained by the limited number of accessible qubits, noise, and decoherence. Thereby, a dataset with exceptionally big dimensionality is difficult to be implemented. In addition, this is where Principal Component Analysis (PCA) comes to help. As mentioned above, PCA is the technique that reduces the huge dimension into smaller-scaled dimensions keeping the correlation given in the dataset. The principal components are orthogonal since they are the eigenvectors of the covariance matrix. Generally, we can assume that the data summarized can be processed by a quantum computer. Using PCA offers us the flexibility to leave out some of the components without losing much information and therefore minimizing the complexity of the problem as illustrated in Figure 15 , where we reduced our dataset in order to handle it with a quantum computer;
• Quantum Feature Map: As we discussed earlier, the Kernel techniques are the set of algorithms for pattern analysis or recognition of the data points. Kernel techniques map data to higher dimensional spaces in order to ease data structure and separability. The data may be translated not only to higher-level space but to an endless dimension. Kernel “trick” is the technique of replacing the inner products of two vectors in our algorithm with the kernel function. In other hand, we have Quantum Kernel techniques which is a method for identifying a hyperplane that is performing a nonlinear transformation to the data, This is termed as a “feature map”. We may either apply available Qiskit (an open-source quantum computing framework created by IBM.) feature maps including ZZ feature map, Z feature map, or a Pauli feature map that has Pauli (X, Y, Z) gates, or create a custom feature map based on the dataset compatibility. The quantum feature map can be built by using Hadamard gates with entangling unitary gates between them. In our case, we used the ZZ feature map. The needed number of qubits is proportional to the data dimensionality. By altering the angle of unitary gates to a certain value, data are encoded. QSVM uses a Quantum processor to estimate the kernel in the feature space. During the training step, the kernel is estimated or computed, and support vectors are obtained. However, in applying the Quantum Kernel method directly, we should encode our training data and test data into proper quantum states. Using Amplitude Encoding, we may encode the training samples in a superposition inside one register, while test examples can be encoded in a second register.

4.2.2. Results

4.3. cnn vs. qcnn.

• Convolutional Neural Networks Convolutional neural networks (CNNs) are a specialized sort of neural networks, built primarily for time series or image processing. They become presently the most frequently used models for image recognition applications. Their abilities have indeed been applied in several sectors such as gravitational wave detection or autonomous vision. Despite these advances, CNNs struggle from a computational limitation which renders deep CNNs extremely pricey in reality. As Figure 18 illustrates, a convolutional neural network generally consists of three components even though the architectural implementation varies considerably: 1. Input: The most popular input is an image, although significant work has also been carried out on so-called 3D convolutional neural networks which can handle either volumetric data (three spatial dimensions) or videos (two spatial dimensions + one temporal dimension). For the majority of the implementations, the input needs to be adjusted to correspond to the specifics of the CNN used. These include cropping, lowering the size of the image, identifying a particular region of interest, and also normalizing pixel values to specified regions. Images, and even more widely layers of a network, may be represented as tensors. The tensor is a generalization of a matrix into extra dimensionality. For example, an image of a height H and a width W may indeed be visualized as just a matrix in R H × W , wherein every pixel represents a greyscale ranging between 0 and 255. Furthermore, all three channels in color RGB (Red Green Blue) should be taken into account, simply layering 3 times the matrix for every color. A whole image is thus viewed as a three-dimensional vector in R H × W × D wherein D represents the number of channels; 2. Feature Learning: The feature learning is built of three principal procedures, executed and repeated in any sequence: Convolution Layers, usually followed with an Activation Function and Pooling Layers at the end of this feature learning process. We indicate by l the present layer. - Convolution Layer: Each l th layer is combined by a collection filter named kernels. The result of this procedure would be the ( l + 1 ) th layer. The convolution using a simple kernel may be considered to be like a feature detector, which will screen through all sections of the input. If a feature described by a kernel, for example, a vertical border, is present through some area of the input, it will be highly valuable at the corresponding point of the outcome. The outcome is known as the feature map of the whole convolution; - Function: Just like in normal neural networks, we add certain nonlinearities also named activation functions. These functions are necessary for a neural network in order to be capable of learning any function. As in implementation of a CNN, every convolution is frequently followed by a Relu (Rectified Linear Unit function). This is a basic function that sets all negative numbers of the output to zero, then leaves the positive values as they are; - Pooling Layer: The downsampling method that reduces the dimensions of the layer, particularly optimizing the calculation. Furthermore, it provides the CNN the capability to learn a form invariant to lower translations. Almost all of the cases, either we use a Maximum Pooling or perhaps an Average Pooling. Maximum Pooling consists of swapping a subsection of P × P components just by another with the biggest value. Average Pooling achieves this by averaging all numbers. Note that the number of a pixel relates to how often a certain feature is represented in the preceding convolution layer; 3. Classification/Fully Connected Layer: Following a specific set of convolution layers, the inputs had been properly handled such that we may deploy a fully connected network. The weights link every input to every output, wherein inputs are all components of the preceding layer. The final layer must include a single node for each possible label. The node value may be read as the probability that the input image belongs to the specified class.
• Quanvolutional Neural Networks The Quanvolutional Neural Networks (QNNs) are essentially a variant of classical convolutional neural networks with an extra transformation layer known as the quanvolutional layer, or quantum convolution that is composed of quanvolutional filters [ 29 ]. When applied, the latter filters to a data input tensor; then, this will individually generate a feature map by changing spatially local subsections of this input. However, unlike the basic handling data element by element in matrix multiplication performed by a traditional convolutional filter, a quanvolutional filter transforms input data using a quantum circuit that may be structured or arbitrary. In our implementation, we employ random quantum circuits as proposed in [ 29 ] for quanvolutional filters rather than circuits with a specific form, for simplicity and to create a baseline. This technique for converting classical data using quanvolutional filters can be formalized as follows and illustrated in Figure 19 : 1. Let us simply begin with a basic quanvolutional filter. The latter filter employs the arbitrary quantum circuit q that accepts as inputs subsections of images of dataset a u . Each input is denoted by the letter u x , with each u x being a two-dimensional matrix of length n -by- n , where n is greater than 1; 2. Despite the fact that there are a variety of methods for “encoding” u x as an initial state of q , we chose one encoding method e for every quanvolutional filter, and we define the resulting state of this encoding with i x = e ( u x ) ; 3. Thereafter, the application of the quantum circuit q to the beginning state i x , and the outcome of the quantum computing was indeed the quantum state o x , as defined by the relation o x = q ( i x ) that also equals q ( e ( u x ) ) ; 4. In order to decode the quantum state o x , we use d which is our decoding method that converts the quantum output into classical output using a set of measurements, which guarantees that the output of the quanvolutional filter is equivalent to the output of a simple classical convolution. The decoded state is described by f x = d ( o x ) with d ( q ( e ( u x ) ) ) in which f x represents a scale value; 5. Lastly, we denote the full transformation achieved by the ’quanvolutional filter transformation’ [ 29 ] by Q of a data point u x , which is also described as f x = Q ( u x , e , q , d ) . Figure 19 B represents one basic quanvolutional filter, showing the encoding, the applying circuit and the decoding process.

Click here to enlarge figure

4.3.1. Implementation

• Dataset: We used a subset of the MNIST (Modified or Mixed National Institute of Standards and Technology) dataset, which includes 70,000 handwritten 28 by 28 pixels in grayscale;
• Implemented models: - The CNN model: We used a simple model: Fully-connected layer containing ten output nodes and then a final activation function softmax in a pure classical convolutional neural network; - The QNN model: A CNN with one quanvolutional layer seems to be the simplest basic quanvolutional neural network. The single quantum layer will be the first, and then the rest of the model is identical to the traditional CNN model;
• Experimental Environment: The Pennylane library [ 80 ] was used to create the implementation, which was then run on the IBM quantum computer simulator QASM;
• Quanvolutional layer generation process described as follows: - A quantum circuit is created by including some small section of the input image, in our case a square of 2 × 2 . A rotation encoding layer denoted by R y (with angles scaled by a factor π ); - The system performs a quantum computation associated with a unit U. A variational quantum circuit or, quite generally, a randomized circuit could generate this unit; - The quantum system is measured using a computational basis measurement, which gives a set of four classical expectation values. The outcomes of the measurements can eventually be post-processed in a classical way; - Each value is translated into a distinct channels of one output pixel, as in a classical convolution layer; - In repeating the technique on different parts, the whole input image can be scanned, thus obtaining an output object structured as a multi-channel; - Other quantum or classical layers can be added after the quanvolutional layer.

4.3.2. Results

5. general discussion, 6. conclusions and perspectives, institutional review board statement, data availability statement, conflicts of interest.

• Grover, L.K. Quantum Mechanics Helps in Searching for a Needle in a Haystack. Phys. Rev. Lett. 1997 , 79 , 325–328. [ Google Scholar ] [ CrossRef ]
• Shor, P.W. Algorithms for Quantum Computation: Discrete Logarithms and Factoring. In Proceedings of the 35th Annual Symposium on Foundation of Computer Science, Washington, DC, USA, 20–22 November 1994; pp. 124–134. [ Google Scholar ]
• Menneer, T.; Narayanan, A. Quantum-inspired neural networks. In Proceedings of the Neural Information Processing Systems 95, Denver, CO, USA, 27–30 November 1995. [ Google Scholar ]
• Rebentrost, P.; Mohseni, M.; Lloyd, S. Quantum Support Vector Machine for Big Data Classification. Phys. Rev. Lett. 2014 , 113 , 130503. [ Google Scholar ] [ CrossRef ] [ PubMed ]
• Harrow, A.W.; Hassidim, A.; Lloyd, S. Quantum Algorithm for Linear Systems of Equations. Phys. Rev. Lett. 2009 , 103 , 150502. [ Google Scholar ] [ CrossRef ] [ PubMed ]
• Wiebe, N.; Kapoor, A.; Svore, K. Quantum algorithms for nearest-neighbor methods for supervised and unsupervised learning. arXiv 2014 , arXiv:1401.2142. [ Google Scholar ] [ CrossRef ]
• Dang, Y.; Jiang, N.; Hu, H.; Ji, Z.; Zhang, W. Image classification based on quantum K-Nearest-Neighbor algorithm. Quantum Inf. Process. 2018 , 17 , 1–18. [ Google Scholar ] [ CrossRef ]
• Schuld, M.; Sinayskiy, I.; Petruccione, F. Prediction by linear regression on a quantum computer. Phys. Rev. A 2016 , 94 , 022342. [ Google Scholar ] [ CrossRef ]
• Lu, S.; Braunstein, S.L. Quantum decision tree classifier. Quantum Inf. Process. 2014 , 13 , 757–770. [ Google Scholar ] [ CrossRef ]
• Lloyd, S.; Mohseni, M.; Rebentrost, P. Quantum algorithms for supervised and unsupervised machine learning. arXiv 2013 , arXiv:1307.0411. [ Google Scholar ]
• Lloyd, S. Least squares quantization in PCM. IEEE Trans. Inf. Theory 1982 , 28 , 129–137. [ Google Scholar ] [ CrossRef ]
• Kerenidis, I.; Landman, J.; Luongo, A.; Prakash, A. q-means: A quantum algorithm for unsupervised machine learning. arXiv 2018 , arXiv:1812.03584. [ Google Scholar ]
• Aïmeur, E.; Brassard, G.; Gambs, S. Quantum speed-up for unsupervised learning. Mach. Learn. 2013 , 90 , 261–287. [ Google Scholar ] [ CrossRef ]
• Lloyd, S.; Mohseni, M.; Rebentrost, P. Quantum principal component analysis. Nat. Phys. 2014 , 10 , 631–633. [ Google Scholar ] [ CrossRef ] [ Green Version ]
• Dong, D.; Chen, C.; Li, H.; Tarn, T.-J. Quantum Reinforcement Learning. IEEE Trans. Syst. Man Cybern. Part B (Cybern.) 2008 , 38 , 1207–1220. [ Google Scholar ] [ CrossRef ]
• Ronagh, P. Quantum algorithms for solving dynamic programming problems. arXiv 2019 , arXiv:1906.02229. [ Google Scholar ]
• McKiernan, K.A.; Davis, E.; Alam, M.S.; Rigetti, C. Automated quantum programming via reinforcement learning for combinatorial optimization. arXiv 2019 , arXiv:1908.08054. [ Google Scholar ]
• Lloyd, S.; Weedbrook, C. Quantum Generative Adversarial Learning. Phys. Rev. Lett. 2018 , 121 , 040502. [ Google Scholar ] [ CrossRef ]
• Dallaire-Demers, P.-L.; Killoran, N. Quantum generative adversarial networks. Phys. Rev. A 2018 , 98 , 012324. [ Google Scholar ] [ CrossRef ]
• Situ, H.; He, Z.; Wang, Y.; Li, L.; Zheng, S. Quantum generative adversarial network for generating discrete distribution. Inf. Sci. 2020 , 538 , 193–208. [ Google Scholar ] [ CrossRef ]
• Huang, H.-L.; Du, Y.; Gong, M.; Zhao, Y.; Wu, Y.; Wang, C.; Li, S.; Liang, F.; Lin, J.; Xu, Y.; et al. Experimental Quantum Generative Adversarial Networks for Image Generation. Phys. Rev. Appl. 2021 , 16 , 024051. [ Google Scholar ] [ CrossRef ]
• Chakrabarti, S.; Yiming, H.; Li, T.; Feizi, S.; Wu, X. Quantum Wasserstein generative adversarial networks. arXiv 2019 , arXiv:1911.00111. [ Google Scholar ]
• Kieferová, M.; Wiebe, N. Tomography and generative training with quantum Boltzmann machines. Phys. Rev. A 2017 , 96 , 062327. [ Google Scholar ] [ CrossRef ]
• Amin, M.H.; Andriyash, E.; Rolfe, J.; Kulchytskyy, B.; Melko, R. Quantum Boltzmann Machine. Phys. Rev. X 2018 , 8 , 021050. [ Google Scholar ] [ CrossRef ]
• Romero, J.; Olson, J.P.; Aspuru-Guzik, A. Quantum autoencoders for efficient compression of quantum data. Quantum Sci. Technol. 2017 , 2 , 045001. [ Google Scholar ] [ CrossRef ]
• Khoshaman, A.; Vinci, W.; Denis, B.; Andriyash, E.; Sadeghi, H.; Amin, M.H. Quantum variational autoencoder. Quantum Sci. Technol. 2018 , 4 , 014001. [ Google Scholar ] [ CrossRef ]
• Cong, I.; Choi, S.; Lukin, M.D. Quantum convolutional neural networks. Nat. Phys. 2019 , 15 , 1273–1278. [ Google Scholar ] [ CrossRef ] [ Green Version ]
• Kerenidis, I.; Landman, J.; Prakash, A. Quantum algorithms for deep convolutional neural networks. arXiv 2019 , arXiv:1911.01117. [ Google Scholar ]
• Henderson, M.; Shakya, S.; Pradhan, S.; Cook, T. Quanvolutional neural networks: Powering image recognition with quantum circuits. Quantum Mach. Intell. 2020 , 2 , 2. [ Google Scholar ] [ CrossRef ]
• Jiang, Z.; Rieffel, E.G.; Wang, Z. Near-optimal quantum circuit for Grover’s unstructured search using a transverse field. Phys. Rev. A 2017 , 95 , 062317. [ Google Scholar ] [ CrossRef ]
• Farhi, E.; Goldstone, J.; Gutmann, S. A quantum approximate optimization algorithm. arXiv 2014 , arXiv:1411.4028. [ Google Scholar ]
• Kerenidis, I.; Prakash, A. Quantum gradient descent for linear systems and least squares. Phys. Rev. A 2020 , 101 , 022316. [ Google Scholar ] [ CrossRef ]
• Schumacher, B. Quantum coding. Phys. Rev. A 1995 , 51 , 2738. [ Google Scholar ] [ CrossRef ] [ PubMed ]
• Barenco, A.; Bennett, C.H.; Cleve, R.; DiVincenzo, D.P.; Margolus, N.; Shor, P.; Sleator, T.; Smolin, J.A.; Weinfurter, H. Elementary gates for quantum computation. Phys. Rev. A 1995 , 52 , 3457–3467. [ Google Scholar ] [ CrossRef ] [ PubMed ]
• Toffoli, T. Reversible computing. In International Colloquium on Automata, Languages, and Programming ; Springer: Berlin/Heidelberg, Germany, 1980; pp. 632–644. [ Google Scholar ]
• Fredkin, E.; Toffoli, T. Conservative logic. Int. J. Theor. Phys. 1982 , 21 , 219–253. [ Google Scholar ] [ CrossRef ]
• Kockum, A.K. Quantum Optics with Artificial Atoms ; Chalmers University of Technology: Gothenburg, Sweden, 2014. [ Google Scholar ]
• Nielsen, M.A.; Chuang, I.; Grover, L.K. Quantum Computation and Quantum Information. Am. J. Phys. 2002 , 70 , 558–559. [ Google Scholar ] [ CrossRef ]
• Deutsch, D.; Jozsa, R. Rapid solution of problems by quantum computation. Proc. R. Soc. Lond. Ser. Math. Phys. Sci. 1992 , 439 , 553–558. [ Google Scholar ] [ CrossRef ]
• Coppersmith, D. An approximate Fourier transform useful in quantum factoring. arXiv 2002 , arXiv:quant-ph/0201067. [ Google Scholar ]
• Xu, N.; Zhu, J.; Lu, D.; Zhou, X.; Peng, X.; Du, J. Quantum Factorization of 143 on a Dipolar-Coupling Nuclear Magnetic Resonance System. Phys. Rev. Lett. 2012 , 108 , 130501. [ Google Scholar ] [ CrossRef ]
• Dridi, R.; Alghassi, H. Prime factorization using quantum annealing and computational algebraic geometry. Sci. Rep. 2017 , 7 , 1–10. [ Google Scholar ]
• Crane, L. Quantum computer sets new record for finding prime number factors. New Scientist , 13 December 2019. [ Google Scholar ]
• David, H. “RSA in a “Pre-Post-Quantum” Computing World”. Available online: https://www.f5.com/labs/articles/threat-intelligence/rsa-in-a-pre-post-quantum-computing-world (accessed on 20 April 2022).
• Aggarwal, D.; Brennen, G.K.; Lee, T.; Santha, M.; Tomamichel, M. Quantum attacks on Bitcoin, and how to protect against them. arXiv 2017 , arXiv:1710.10377. [ Google Scholar ] [ CrossRef ] [ Green Version ]
• Peruzzo, A.; McClean, J.; Shadbolt, P.; Yung, M.-H.; Zhou, X.-Q.; Love, P.J.; Aspuru-Guzik, A.; O’Brien, J.L. A variational eigenvalue solver on a photonic quantum processor. Nat. Commun. 2014 , 5 , 4213. [ Google Scholar ] [ CrossRef ]
• Wikipedia. Quantum Machine Learning. Last Modified 6 June 2021. 2021. Available online: https://en.wikipedia.org/w/index.php?title=Quantum_machine_learning&oldid=1055622615 (accessed on 20 April 2022).
• Stoudenmire, E.; Schwab, D.J. Supervised learning with quantum-inspired tensor networks. arXiv 2016 , arXiv:1605.05775. [ Google Scholar ]
• Aaronson, S. The learnability of quantum states. Proc. R. Soc. A Math. Phys. Eng. Sci. 2007 , 463 , 3089–3114. [ Google Scholar ] [ CrossRef ]
• Sasaki, M.; Carlini, A. Quantum learning and universal quantum matching machine. Phys. Rev. A 2002 , 66 , 022303. [ Google Scholar ] [ CrossRef ]
• Bisio, A.; Chiribella, G.; D’Ariano, G.M.; Facchini, S.; Perinotti, P. Optimal quantum learning of a unitary transformation. Phys. Rev. A 2010 , 81 , 032324. [ Google Scholar ] [ CrossRef ]
• da Silva, A.J.; Ludermir, T.B.; de Oliveira, W.R. Quantum perceptron over a field and neural network architecture selection in a quantum computer. Neural Netw. 2016 , 76 , 55–64. [ Google Scholar ] [ CrossRef ]
• Tiwari, P.; Melucci, M. Towards a Quantum-Inspired Binary Classifier. IEEE Access 2019 , 7 , 42354–42372. [ Google Scholar ] [ CrossRef ]
• Sergioli, G.; Giuntini, R.; Freytes, H. A new quantum approach to binary classification. PLoS ONE 2019 , 14 , e0216224. [ Google Scholar ] [ CrossRef ]
• Ding, C.; Bao, T.Y.; Huang, H.L. Quantum-inspired support vector machine. IEEE Trans. Neural Netw. Learn. Syst. 2021 , 33 , 7210–7222. [ Google Scholar ] [ CrossRef ]
• Sergioli, G.; Russo, G.; Santucci, E.; Stefano, A.; Torrisi, S.E.; Palmucci, S.; Vancheri, C.; Giuntini, R. Quantum-inspired minimum distance classification in a biomedical context. Int. J. Quantum Inf. 2018 , 16 , 18400117. [ Google Scholar ] [ CrossRef ]
• Chen, H.; Gao, Y.; Zhang, J. Quantum k-nearest neighbor algorithm. Dongnan Daxue Xuebao 2015 , 45 , 647–651. [ Google Scholar ]
• Yu, C.H.; Gao, F.; Wen, Q.Y. An improved quantum algorithm for ridge regression. IEEE Trans. Knowl. Data Eng. 2019 , 33 , 858–866. [ Google Scholar ] [ CrossRef ] [ Green Version ]
• Sagheer, A.; Zidan, M.; Abdelsamea, M.M. A Novel Autonomous Perceptron Model for Pattern Classification Applications. Entropy 2019 , 21 , 763. [ Google Scholar ] [ CrossRef ] [ PubMed ]
• Adhikary, S.; Dangwal, S.; Bhowmik, D. Supervised learning with a quantum classifier using multi-level systems. Quantum Inf. Process. 2020 , 19 , 89. [ Google Scholar ] [ CrossRef ]
• Havlíček, V.; Córcoles, A.D.; Temme, K.; Harrow, A.W.; Kandala, A.; Chow, J.M.; Gambetta, J.M. Supervised learning with quantum-enhanced feature spaces. Nature 2019 , 567 , 209–212. [ Google Scholar ] [ CrossRef ]
• Ruan, Y.; Xue, X.; Liu, H.; Tan, J.; Li, X. Quantum Algorithm for K-Nearest Neighbors Classification Based on the Metric of Hamming Distance. Int. J. Theor. Phys. 2017 , 56 , 3496–3507. [ Google Scholar ] [ CrossRef ]
• Zhang, D.B.; Zhu, S.L.; Wang, Z.D. Nonlinear regression based on a hybrid quantum computer. arXiv 2018 , arXiv:1808.09607. [ Google Scholar ]
• Cortese, J.A.; Braje, T.M. Loading classical data into a quantum computer. arXiv 2018 , arXiv:1803.01958. [ Google Scholar ]
• Schuld, M.; Killoran, N. Quantum Machine Learning in Feature Hilbert Spaces. Phys. Rev. Lett. 2019 , 122 , 040504. [ Google Scholar ] [ CrossRef ]
• Schuld, M.; Petruccione, F. Supervised Learning with Quantum Computers ; Springer: Berlin/Heidelberg, Germany, 2018; Volume 17. [ Google Scholar ]
• Wikipedia. Amplitude Amplification. Last Modified 5 April 2021. 2021. Available online: https://en.wikipedia.org/w/index.php?title=Amplitude_amplification&oldid=1021327631 (accessed on 24 June 2022).
• Cerezo, M.; Arrasmith, A.; Babbush, R.; Benjamin, S.C.; Endo, S.; Fujii, K.; McClean, J.R.; Mitarai, K.; Yuan, X.; Cincio, L.; et al. Variational quantum algorithms. Nat. Rev. Phys. 2021 , 3 , 625–644. [ Google Scholar ] [ CrossRef ]
• Biamonte, J.; Wittek, P.; Pancotti, N.; Rebentrost, P.; Wiebe, N.; Lloyd, S. Quantum machine learning. Nature 2017 , 549 , 195–202. [ Google Scholar ] [ CrossRef ]
• Coyle, B.; Mills, D.; Danos, V.; Kashefi, E. The Born supremacy: Quantum advantage and training of an Ising Born machine. NPJ Quantum Inf. 2020 , 6 , 60. [ Google Scholar ] [ CrossRef ]
• Biamonte, J. Universal variational quantum computation. Phys. Rev. A 2021 , 103 , L030401. [ Google Scholar ] [ CrossRef ]
• Abbas, A.; Sutter, D.; Zoufal, C.; Lucchi, A.; Figalli, A.; Woerner, S. The power of quantum neural networks. Nat. Comput. Sci. 2021 , 1 , 403–409. [ Google Scholar ] [ CrossRef ]
• Mitarai, K.; Negoro, M.; Kitagawa, M.; Fujii, K. Quantum circuit learning. Phys. Rev. A 2018 , 98 , 032309. [ Google Scholar ] [ CrossRef ]
• Bishwas, A.K.; Mani, A.; Palade, V. An all-pair quantum SVM approach for big data multiclass classification. Quantum Inf. Process. 2018 , 17 , 282. [ Google Scholar ] [ CrossRef ]
• Wiebe, N.; Braun, D.; Lloyd, S. Quantum Algorithm for Data Fitting. Phys. Rev. Lett. 2012 , 109 , 050505. [ Google Scholar ] [ CrossRef ]
• Kapoor, A.; Wiebe, N.; Svore, K. Quantum perceptron models. arXiv 2016 , arXiv:1602.04799. [ Google Scholar ]
• Schuld, M.; Bocharov, A.; Svore, K.M.; Wiebe, N. Circuit-centric quantum classifiers. Phys. Rev. A 2020 , 101 , 032308. [ Google Scholar ] [ CrossRef ]
• Chen, S.Y.-C.; Yang, C.-H.H.; Qi, J.; Chen, P.-Y.; Ma, X.; Goan, H.-S. Variational Quantum Circuits for Deep Reinforcement Learning. IEEE Access 2020 , 8 , 141007–141024. [ Google Scholar ] [ CrossRef ]
• Anguita, D.; Ridella, S.; Rivieccio, F.; Zunino, R. Quantum optimization for training support vector machines. Neural Netw. 2003 , 16 , 763–770. [ Google Scholar ] [ CrossRef ]
• Bergholm, V.; Izaac, J.; Schuld, M.; Gogolin, C.; Alam, M.S.; Ahmed, S.; Arrazola, J.M.; Blank, C.; Delgado, A.; Jahangiri, S.; et al. Pennylane: Automatic differentiation of hybrid quantum-classical computations. arXiv 2018 , arXiv:1811.04968. [ Google Scholar ]
• Aleksandrowicz, G.; Alexander, T.; Barkoutsos, P.; Bello, L.; Ben-Haim, Y.; Bucher, D.; Cabrera-Hernández, F.J.; Carballo-Franquis, J.; Chen, A.; Chen, C.F.; et al. Qiskit: An Open-Source Framework for Quantum Computing. 2019. Available online: https://zenodo.org/record/2562111 (accessed on 26 June 2022).
• Buitinck, L.; Louppe, G.; Blondel, M.; Pedregosa, F.; Mueller, A.; Grisel, O.; Niculae, V.; Prettenhofer, P.; Gramfort, A.; Grobler, J.; et al. API design for machine learning software: Experiences from the scikit-learn project. arXiv 2013 , arXiv:1309.0238. [ Google Scholar ]

Before Applying CNOT		After Applying CNOT

Input	H	CNOT

Quantum Routines	QML Applications
HHL algorithm	QSVM [ , ]
	Q linear regression [ ]
	Q least squares [ ]
	QPCA [ ]
Grover’s algorithm	Q k-Means [ ]
	Q K-Median [ ]
	QKNN [ ]
	Q Perceptron Models [ ]
	Q Neural Networks [ ]
Quantum phase estimation	Q k-Means [ ]
Variational quantum circuit	Q decision tree [ ]
	Circuit-centric quantum
	classifiers [ ]
	Deep reinforcement
	learning [ ]

Metric	VQC	SVC	Decision Tree	Naive Bayes
Accuracy	1	0.96	0.96	0.96
Cost	0.2351166	0.0873071	0.0906691	1.381551

Algorithm	Loss Function	Test Accuracy
	1.0757	0.6667
	0.9882	0.7000

The statements, opinions and data contained in all publications are solely those of the individual author(s) and contributor(s) and not of MDPI and/or the editor(s). MDPI and/or the editor(s) disclaim responsibility for any injury to people or property resulting from any ideas, methods, instructions or products referred to in the content.

Share and Cite

Zeguendry, A.; Jarir, Z.; Quafafou, M. Quantum Machine Learning: A Review and Case Studies. Entropy 2023 , 25 , 287. https://doi.org/10.3390/e25020287

Zeguendry A, Jarir Z, Quafafou M. Quantum Machine Learning: A Review and Case Studies. Entropy . 2023; 25(2):287. https://doi.org/10.3390/e25020287

Zeguendry, Amine, Zahi Jarir, and Mohamed Quafafou. 2023. "Quantum Machine Learning: A Review and Case Studies" Entropy 25, no. 2: 287. https://doi.org/10.3390/e25020287

Article Metrics

Article access statistics, further information, mdpi initiatives, follow mdpi.

Subscribe to receive issue release notifications and newsletters from MDPI journals

quantum machine learning Recently Published Documents

Total documents.

• Latest Documents
• Most Cited Documents
• Contributed Authors
• Related Sources
• Related Keywords

An Optimizing Method for Performance and ResourceUtilization in Quantum Machine Learning Circuits

Abstract Quantum computing is a new and advanced topic that refers to calculations based on the principles of quantum mechanics. Itmakes certain kinds of problems be solved easier compared to classical computers. This advantage of quantum computingcan be used to implement many existing problems in different fields incredibly effectively. One important field that quantumcomputing has shown great results in machine learning. Until now, many different quantum algorithms have been presented toperform different machine learning approaches. In some special cases, the execution time of these quantum algorithms will bereduced exponentially compared to the classical ones. But at the same time, with increasing data volume and computationtime, taking care of systems to prevent unwanted interactions with the environment can be a daunting task and since thesealgorithms work on machine learning problems, which usually includes big data, their implementation is very costly in terms ofquantum resources. Here, in this paper, we have proposed an approach to reduce the cost of quantum circuits and to optimizequantum machine learning circuits in particular. To reduce the number of resources used, in this paper an approach includingdifferent optimization algorithms is considered. Our approach is used to optimize quantum machine learning algorithms forbig data. In this case, the optimized circuits run quantum machine learning algorithms in less time than the original onesand by preserving the original functionality. Our approach improves the number of quantum gates by 10.7% and 14.9% indifferent circuits and the number of time steps is reduced by three and 15 units, respectively. This is the amount of reduction forone iteration of a given sub-circuit U in the main circuit. For cases where this sub-circuit is repeated more times in the maincircuit, the optimization rate is increased. Therefore, by applying the proposed method to circuits with big data, both cost andperformance are improved.

Modeling of Supervised Machine Learning using Mechanism of Quantum Computing.

Abstract Mechanism of quantum computing helps to propose several task of machine learning in quantum technology. Quantum computing is enriched with quantum mechanics such as superposition and entanglement for making new standard of computation which will be far different than classical computer. Qubit is sole of quantum technology and help to use quantum mechanism for several tasks. Tasks which are non-computable by classical machine can be solved by quantum technology and these tasks are classically hard to compute and categorised as complex computations. Machine learning on classical models is very well set but it has more computational requirements based on complex and high-volume data processing. Supervised machine learning modelling using quantum computing deals with feature selection, parameter encoding and parameterized circuit formation. This paper highlights on integration of quantum computation and machine learning which will make sense on quantum machine learning modeling. Modelling of quantum parameterized circuit, Quantum feature set design and implementation for sample data is discussed. Supervised machine learning using quantum mechanism such as superposition and entanglement are articulated. Quantum machine learning helps to enhance the various classical machine learning methods for better analysis and prediction using complex measurement.

Quantum Machine Learning Algorithm for Iron, Gold, and Copper Detection in Optical Remote Sensing Data

A quantum-enhanced precision medicine application to support data-driven clinical decisions for the personalized treatment of advanced knee osteoarthritis: development and preliminary validation of precisionknee qnn.

Background Quantum computing (QC) and quantum machine learning (QML) are promising experimental technologies which can improve precision medicine applications by reducing the computational complexity of algorithms driven by big, unstructured, real-world data. The clinical problem of knee osteoarthritis is that, although some novel therapies are safe and effective, the response is variable, and defining the characteristics of an individual who will respond remains a challenge. In this paper we tested a quantum neural network (QNN) application to support precision data-driven clinical decisions to select personalized treatments for advanced knee osteoarthritis. Methods Following patients consent and Research Ethics Committee approval, we collected clinico-demographic data before and after the treatment from 170 patients eligible for knee arthroplasty (Kellgren-Lawrence grade ≥ 3, OKS ≤ 27, Age ≥ 64 and idiopathic aetiology of arthritis) treated over a 2 year period with a single injection of microfragmented fat. Gender classes were balanced (76 M, 94 F) to mitigate gender bias. A patient with an improvement ≥ 7 OKS has been considered a Responder. We trained our QNN Classifier on a randomly selected training subset of 113 patients to classify responders from non-responders (73 R, 40 NR) in pain and function at 1 year. Outliers were hidden from the training dataset but not from the validation set. Results We tested our QNN Classifier on a randomly selected test subset of 57 patients (34 R, 23 NR) including outliers. The No Information Rate was equal to 0.59. Our application correctly classified 28 Responders out of 34 and 6 non-Responders out of 23 (Sensitivity = 0.82, Specificity = 0.26, F1 Statistic= 0.71). The Positive (LR+) and Negative (LR-) Likelihood Ratios were respectively 1.11 and 0.68. The Diagnostic Odds Ratio (DOR) was equal to 2. Conclusions Preliminary results on a small validation dataset show that quantum machine learning applied to data-driven clinical decisions for the personalized treatment of advanced knee osteoarthritis is a promising technology to reduce computational complexity and improve prognostic performance. Our results need further research validation with larger, real-world unstructured datasets, and clinical validation with an AI Clinical Trial to test model efficacy, safety, clinical significance and relevance at a public health level.

Data-Driven Modeling of S0 →S1 Excitation Energy in the BODIPY Chemical Space: High-Throughput Computation, Quantum Machine Learning, and Inverse Design

Invited: drug discovery approaches using quantum machine learning, invited: trainable discrete feature embeddings for quantum machine learning, computational identification of inhibitors of msut‐2 using quantum machine learning and molecular docking for the treatment of alzheimer's disease, clustering and enhanced classification using a hybrid quantum autoencoder.

Abstract Quantum machine learning (QML) is a rapidly growing area of research at the intersection of classical machine learning and quantum information theory. One area of considerable interest is the use of QML to learn information contained within quantum states themselves. In this work, we propose a novel approach in which the extraction of information from quantum states is undertaken in a classical representational-space, obtained through the training of a hybrid quantum autoencoder (HQA). Hence, given a set of pure states, this variational QML algorithm learns to identify – and classically represent – their essential distinguishing characteristics, subsequently giving rise to a new paradigm for clustering and semi-supervised classification. The analysis and employment of the HQA model are presented in the context of amplitude encoded states – which in principle can be extended to arbitrary states for the analysis of structure in non-trivial quantum data sets.

An introduction to quantum machine learning: from quantum logic to quantum deep learning

Export citation format, share document.

An official website of the United States government

The .gov means it’s official. Federal government websites often end in .gov or .mil. Before sharing sensitive information, make sure you’re on a federal government site.

The site is secure. The https:// ensures that you are connecting to the official website and that any information you provide is encrypted and transmitted securely.

• Publications
• Account settings

Preview improvements coming to the PMC website in October 2024. Learn More or Try it out now .

• Advanced Search
• Journal List
• Entropy (Basel)

Quantum Machine Learning: A Review and Case Studies

Amine zeguendry.

1 Laboratoire d’Ingénierie des Systèmes d’Information, Faculty of Sciences, Cadi Ayyad University, Marrakech 40000, Morocco

Mohamed Quafafou

2 Laboratoire des Sciences de l’Information et des Systèmes, Unité Mixte de Recherche 7296, Aix-Marseille University, 13007 Marseille, France

Associated Data

The notebooks used during this study can be provided after contacting the authors.

Despite its undeniable success, classical machine learning remains a resource-intensive process. Practical computational efforts for training state-of-the-art models can now only be handled by high speed computer hardware. As this trend is expected to continue, it should come as no surprise that an increasing number of machine learning researchers are investigating the possible advantages of quantum computing. The scientific literature on Quantum Machine Learning is now enormous, and a review of its current state that can be comprehended without a physics background is necessary. The objective of this study is to present a review of Quantum Machine Learning from the perspective of conventional techniques. Departing from giving a research path from fundamental quantum theory through Quantum Machine Learning algorithms from a computer scientist’s perspective, we discuss a set of basic algorithms for Quantum Machine Learning, which are the fundamental components for Quantum Machine Learning algorithms. We implement the Quanvolutional Neural Networks (QNNs) on a quantum computer to recognize handwritten digits, and compare its performance to that of its classical counterpart, the Convolutional Neural Networks (CNNs). Additionally, we implement the QSVM on the breast cancer dataset and compare it to the classical SVM. Finally, we implement the Variational Quantum Classifier (VQC) and many classical classifiers on the Iris dataset to compare their accuracies.

1. Introduction

Machine Learning is a subset of Artificial Intelligence (AI) that aims to create models that learn from previous experience without being explicitly formulated, and it has been used extensively in several scientific and technical fields, including natural language processing, medical diagnostics, computer vision, and data mining, and so on. Many machine learning problems require the use of linear algebra to execute matrix operations since data are described as matrices. On the other hand, performing these operations on traditional computers requires a significant amount of time and computational resources. Quantum Computing is an ambitious new field that combines computer science, mathematics, and physics. This field investigates ways to use some of the special properties of quantum physics to build quantum computers that take advantage of quantum bits (qubits) that can contain 0 and 1 combinations in superposition at the same time. As a result, quantum computers can handle and process large matrices, as well as accelerate various linear algebra operations, significantly improving traditional machine learning applications. Theoretically, it should solve problems that belong to classes of complexity that traditional computers, even large giant supercomputers, will never be able to solve. Grover’s algorithm, for instance, has demonstrated a quadratic speedup for exploring unstructured databases [ 1 ], while Shor’s technique [ 2 ] illustrates that quantum computing may provide an exponential speedup in solving the traditionally difficult problem of big integer factorization. These algorithms are anticipated to include some key characteristics of quantum computation, including quantum superposition, quantum measurement, and quantum entanglement.

While machine learning is being limited by a lack of computing power, researchers are exploring the prospects of combining quantum computing and machine learning to handle classical data using machine learning algorithms. This combination of machine learning theory with the characteristics of quantum computing is a new research sub-discipline called Quantum Machine Learning (QML). Therefore, QML aims to build quantum applications for diverse machine learning algorithms, using the processing power of quantum computers and the scalability and learning capacity of machine learning algorithms.

Quantum variants of several popular algorithms for machine learning are already developed. Quantum Neural Network (QNN) described by Narayanan and Menneer [ 3 ], in which they presented the theoretical design of a QNN architecture and how the system’s components might perform relative to their traditional counterparts. Quantum Support Vector Machines (QSVM) was proposed by Rebentrost et al. [ 4 ] for solving least-squares SVM using the HHL algorithm [ 5 ] for matrix inversion in order to generate the hyperplane. In 2014, Wiebe et al. [ 6 ] provided a quantum version of k-nearest neighbors for computing the nearest neighbors relying on the Euclidean distance between the data locations, in addition to amplitude estimation which eliminates the requirement for measurement. In 2018, Dang et al. [ 7 ] also introduced an image classification model based on quantum k-nearest neighbors and parallel computing. Their model improved categorization precision and productivity. Schuld et al. [ 8 ] proposed quantum linear regression as a version of classical linear regression, and it operates in an exponential runtime with N dimensions of features, using quantum data, which is presented as quantum information. The quantum decision tree classifier developed by Lu et al. [ 9 ] employs quantum fidelity measurement and quantum entropy impurity.

Lloyd et al. [ 10 ] described several quantum machine learning techniques for cluster detection and cluster assignment. A quantization version of Lloyd’s method [ 11 ] is provided as a part of their k-means clustering algorithm. Furthermore, Kerenidis et al. [ 12 ] have suggested Q-means, a quantized form of the k-means method with similar results and convergence to the traditional k-means algorithm. Aïmeur et al. [ 13 ] introduced quantum K-medians clustering, which uses Grover’s search algorithm for locating the cluster’s median. In 2014, Lloyd et al. [ 14 ] developed Quantum Principal Component Analysis (QPCA), which identifies the eigenvectors relating to the unknown state’s huge eigenvalues exponentially faster than any other solution.

Inside Machine Learning, there is a more advanced field known as Reinforcement Learning. It is built on continuous learning through exploration of the environment. There exist few quantum variants of conventional Reinforcement Learning algorithms including Quantum Reinforcement Learning introduced by Dong et al. [ 15 ], which makes use of the quantum parallelism and superposition principle. They discovered that probability amplitude and quantum parallelism may aid in learning speed. For solving Dynamic Programming problems, which are deterministic forms of Markov decision problems that are studied in reinforcement learning, in [ 16 ], they have suggested various quantum algorithms as solutions. McKiernan et al. [ 17 ] developed a general algorithm to improve hybrid quantum-classical computing using reinforcement learning.

Deep Learning is a new machine learning sub-discipline. Deep Learning techniques, which demand a significant amount of storage and time consumption, are now being implemented on quantum computers. These algorithms are shown by Quantum Generative Adversarial Networks (Quantum GAN) [ 18 , 19 , 20 ] with its implementation in [ 21 ], which uses a superconducting quantum processor to learn and generate real-world handwritten digit pictures, Quantum Wasserstein Generative Adversarial Networks (Quantum WGAN) [ 22 ], which improves the scalability and stability of quantum generative adversarial model training on quantum machines, Quantum Boltzmann Machines [ 23 , 24 ], Quantum Autoencoders [ 25 , 26 ], and Quantum Convolutional Neural Networks [ 27 , 28 , 29 ], and the latter is implemented in the benchmark section.

Optimization is also important in conventional machine learning, since most of the time learning training machine learning models are based on optimizing cost functions. Numerical optimization techniques are a major field of study that tries to enhance optimization algorithm computations. Quantum-enhanced Optimization (QEO) [ 30 ], a sub-field of quantum computing, intends to augment these techniques even further, similar to conventional optimization. Quantum Approximate Optimization Algorithm and Quantum Gradient Descent [ 31 , 32 ] are two well-known examples of this type, which are used within Quantum Neural Networks such as Quantum Boltzman Machines [ 24 ].

In this paper, we aim to introduce quantum computing to the field of machine learning from a basics perspective all the way to its applications. The remainder of this work is structured as follows. In Section 2 , we explore the background of quantum computing, the architecture of quantum computers, and an introduction to quantum algorithms. In Section 3 , we start introducing several fundamental algorithms for quantum machine learning that are the fundamental components of QML algorithms and can primarily offer a performance boost over conventional machine learning algorithms, and we discuss a few popular quantum machine learning algorithms. In Section 4 , we implement three machine learning algorithms in order to compare the performance of each algorithm with its classical counterparts. In the final sections, ahead of the conclusions and perspectives, we discuss some quantum computer challenges.

2. Background

Quantum computing uses quantum physics principles including s u p e r p o s i t i o n , e n t a n g l e m e n t , and q u a n t u m m e a s u r e m e n t , to process data. Superposition is the quantum mechanical feature that permits objects to exist in several states simultaneously. Entanglement may join two or even more quantum particles in full synchronization, despite being on different sides of the universe. Quantum measurement is a process that transforms quantum information into classical information. This section provides an introduction to the basics of quantum computing, from Dirac notations through quantum algorithms.

2.1. Dirac (Bra-Ket) Notation

States and operators in quantum mechanics are represented as vectors and matrices, respectively. Instead of utilizing standard linear algebra symbols, Dirac notation is used to represent the vectors.

Let a and b be in C 2 :

• Ket: | a 〉 = a 1 a 2 . (1)

Note that the complex conjugate of any complex number can be generated by inverting the sign of its imaginary component—for example, the complex conjugate of b = a + i × d is b * = a − i × d .

• Bra-Ket: Inner product 〈 b | a 〉 = a 1 b 1 * + a 2 b 2 * = 〈 a | b 〉 * . (3)
• Ket-Bra: Outer product | a 〉 〈 b | = a 1 b 1 * a 1 b 2 * a 2 b 1 * a 2 b 2 * . (4)

The bit is the standard measure of information in classical computing. It could exist in one of two states: 0 or 1. Quantum computers, similarly, use a “qubit” that is also called “quantum bit” [ 33 ], which represents the likelihood of an electron’s “spin up” or “spin down” when passing through some kind of a magnetic field. In traditional computing, the spin may be thought of as the value of a bit. A qubit may be considered as the complex two-dimensional Hilbert space C 2 . An instantaneous qubit state can be expressed as a vector in this multidimensional Hilbert space.

An inner product between two vectors that represent qubit states in Hilbert space allows us to identify their relative positions. 〈 a | b 〉 represents the inner product of the vectors | a 〉 and | b 〉 ; it equals 0 if | a 〉 and | b 〉 are orthogonal and 1 if | a 〉 = | b 〉 .

The states | 0 〉 and | 1 〉 can be represented with vectors, as shown below. These two are known as the c o m p u t a t i o n a l b a s i s of a two-level system. These vectors in the state space are then susceptible to matrix-based operators:

A qubit could be in one of three states: | 0 〉 , | 1 〉 , or a superposition of both,

where the coefficients c 1 , c 2 ∈ C , called a m p l i t u d e s . According to the Born rule, the total of the squares of the amplitudes of all possible states in a superposition equals 1:

When we perform a m e a s u r e m e n t , we obtain a single bit of information: 0 or 1. The most basic measurement is in the computational basis (Z-Basis: | 0 〉 , | 1 〉 ). For example, the result of measuring the state c 1 | 0 〉 + c 2 | 1 〉 in the computational basis is 0 with probability | c 1 | 2 and 1 with probability | c 2 | 2 .

There are numerous different bases; however, below are some of the most common ones:

• X-Basis: | + 〉 : = 1 2 | 0 〉 + | 1 〉 , | − 〉 : = 1 2 | 0 〉 − | 1 〉
• Y-Basis: | + i 〉 : = 1 2 | 0 〉 + i | 1 〉 , | − i 〉 : = 1 2 | 0 〉 − i | 1 〉

The probability that a state | ψ 〉 collapses during a measurement in the basis | b 〉 , | b * 〉 , for the state | b 〉 is provided by P ( b ) = 〈 b | ψ 〉 2 ; Σ i P ( b ) = 1 , as claimed by the Born rule. For example, we measure the state | ψ 〉 = 1 3 | 0 〉 + 2 | 1 〉 in the | 0 〉 , | 1 〉 basis,

P ( 0 ) = 〈 0 | 1 3 | 0 〉 + 2 | 1 〉 〉 2 = 1 3 〈 0 | 0 〉 + 2 3 〈 0 | 1 〉 2 = 1 3 and P ( 1 ) = 1 − 1 3 = 2 3 , where 〈 0 | 0 〉 = 1 (normalized) and 〈 0 | 1 〉 = 0 (orthogonal); thus, the qubit is in the state | 1 〉 .

2.3. Quantum Circuit

Quantum circuits are represented using circuit diagrams. These diagrams are built and read from left to right. Barenco et al. [ 34 ] defined several of the basic operators that we now use in quantum circuits today. Two binary operators were added to this set by Toffoli and Fredkin [ 35 , 36 ]. We start building a quantum circuit with a line representing a circuit wire. As seen in Figure 1 a, on the left side of the wire, a ket indicates its original condition of state preparation.

Representations of wires of quantum circuit. ( a ) Single quantum circuit wire; ( b ) Quantum circuit wire with n qubits.

The qubit stays in the state in which it was originally created if there is no operator on the line. This indicates that the qubit state is maintained by the quantum computer.

The number of qubits produced in that condition is denoted by a slash n sign all over the wire as shown in Figure 1 b.

A quantum circuit is a computer process that combines traditional real-time computation with coherent q u a n t u m g a t e s on quantum data such as qubits.

2.4. Quantum Gates

Quantum gates or operators fundamentally involve the modification of one or more qubits. Single-qubit gates are represented as a box with the letter of the operator straddling the line. An operator box connecting two quantum wires is the basis of a binary gate.

2.4.1. Single Qubit Gates

Pauli matrices are the first of three operators we examine, which are used to represent certain typical quantum gates.

When we apply X to | 0 〉 , we obtain

As we can see, this gate flips the amplitudes of the | 0 〉 and | 1 〉 states. In a quantum circuit, the symbol in Figure 2 a represents the Pauli-X gate.

Circuit representations of the four most used gates in quantum circuits. ( a ) The Pauli-Y gate; ( b ) The Pauli-Y gate; ( c ) The Pauli-Z gate; ( d ) The CNOT gate.

Consequently, when it is applied to the | 1 〉 state, we obtain

In Figure 2 b, the circuit design for the Y operator is displayed.

By applying the Pauli-Z gate to the computational basis state, we obtain the result shown below:

For the particular case u = 0 , we present it in matrix form:

We have in the case where u = 1 ,

The Pauli-Z gate’s circuit diagram is shown in Figure 2 c.

The matrix below represents the phase shift gate:

where φ denotes the phase shift over a period of 2π. Typical instances include the Pauli-Z gate where φ = π , T gate where φ = π 4 , and S gate where φ = π 2 .

When Hadamard gate is applied to the state | 0 〉 , we obtain

and to state | 1 〉 , we obtain

As can be seen, the Hadamard gate projects a computational basis state into the superposition of two states.

2.4.2. Multi Qubit States and Gates

A single bit offers two possible states; in addition, a qubit state contains two complex amplitudes, as we saw before. Similarly, two bits might be in one of four states: 00, 10, 01, or 11. Four complex amplitudes are needed to present the state of two qubits. These amplitudes are stored in a 4D-vector:

The tensor product ⊗ can be used to characterize the combined state of two separated qubits:

States of this form ( | v 〉 ⊗ | u 〉 ) called uncorrelated, but there are also bipartite states which cannot be expressed as | v 〉 ⊗ | u 〉 ; these states are correlated and sometimes e n t a n g l e d .

The CNOT or CX gate is one of several quantum gates which perform on multi qubits, if the first qubit is in state | 1 〉 , the second qubit will execute the NOT operation, otherwise leaving it unaltered. Using the CNOT gate, we entangle two qubits in a quantum circuit. This gate is described by the following matrix:

As an instance, the CNOT gate may be applied to the state | 10 〉 as follows:

The Table 1 reveals that the output state of the targeted qubit matches that of a conventional XOR gate. The targeted qubit is | 0 〉 when both inputs are the same, but | 1 〉 when the inputs are different. We represent the CNOT gate with the circuit’s diagram in Figure 2 d.

CNOT gate truth table.

Before Applying CNOT		After Applying CNOT

2.5. Representation of Qubit States

The state of a qubit may be represented with different ways. Dirac notation allows us to express this state in a readable form. A qubit in state | 0 〉 , for instance, will transfer to state | 1 〉 after the application of the X operator.

In Figure 3 , a state of a single qubit is represented by the Bloch sphere. Quantum states are represented by vectors that extend from the origin to a certain point on the surface of the Bloch sphere. The top and bottom antipodes of the sphere are | 0 〉 and | 1 〉 , respectively.

Bloch sphere representation of the state of qubit. Reprinted with permission from Ref. [ 37 ]. 2014, Anton Frisk Kockum.

On the Bloch sphere, we may write any p u r e s t a t e (i.e., a qubit state specified by a vector of norm 1. M i x e d s t a t e , in contrast, is a state that combines numerous pure quantum states or qubits) as seen below:

with θ ∈ [ 0 , π ] , determines the probability to measure the state | 0 〉 as P ( 0 ) = cos 2 θ / 2 and the state | 1 〉 as P ( 1 ) = sin 2 θ / 2 , and ϕ ∈ [ 0 , 2 π ] describes the relative phase. On the surface of a Bloch sphere, all of these pure states may be represented with a radius of | r → | = 1 . The Bloch vector generates such a state’s coordinates:

• | 0 〉 : θ = 0 , ϕ arbitrary → r → = ( 0 , 0 , 1 ) ;
• | 1 〉 : θ = π , ϕ arbitrary → r → = ( 0 , 0 , − 1 ) ;
• | + 〉 : θ = π / 2 , ϕ = 0 → r → = ( 1 , 0 , 0 ) ;
• | − 〉 : θ = π / 2 , ϕ = π → r → = ( − 1 , 0 , 0 ) ;
• | + i 〉 : θ = π / 2 , ϕ = π / 2 → r → = ( 0 , 1 , 0 ) ;
• | − i 〉 : θ = π / 2 , ϕ = 3 π / 2 → r → = ( 0 , − 1 , 0 ) .

Bloch sphere is only capable of representing the state of a particular qubit. Therefore, the Q − s p h e r e is used for multi-qubits (and single qubits as well).

Representations of single qubit and multi-qubit in Q-sphere. ( a ) Representation of a superposition state; ( b ) Representation of three-qubit states.

• - The south pole represents the state | 1 〉 ;
• - The north pole represents the state | 0 〉 ;
• - The size of the blobs is related to the likelihood that the relevant state will be measured;
• - The color indicates the relative phase compared to the state | 0 〉 .

In Figure 4 b, we plot all states as equally distributed points on sphere with 0 ⊗ n on the north pole, 1 ⊗ n on the south pole, and all other state are aligned on parallels, such as the number of “1”s on each latitude is constant and increasing from north to south.

2.6. Entanglement

Quantum entanglement is a phenomena wherein quantum particles interact and are represented by reference to one another despite their great distance apart. At the point of measurement, if one of the entangled particles in a pair is determined to be in the ’down’ spin state, this state is instantly transmitted to the other particle, which now adopts the opposite spin, state of ’up’. Even if entangled particles were positioned on opposite corners of the universe, they would remain “connected”. This example is significant because it demonstrates how wave–particle duality qualities may be used to allow qubits to interact with quantum algorithms via i n t e r f e r e n c e in some cases. We consider, for example, the state 1 2 | 00 〉 + | 11 〉 (which is a B e l l s t a t e ), and this state has a chance of 50 percent of being measured in state | 00 〉 and another half chance of being measured in the state | 11 〉 . The measurement of one causes the superposition to collapse and seems to have an instantaneous impact on the other.

The Bell states, also called EPR pairs, are quantum states with two qubits that represent the simplest (and most extreme) forms of quantum entanglement; they are a form of normalized and entangled basis vectors. This normalization indicates that the particle’s overall probability of being in one of the states stated is 1: 〈 ψ | ψ 〉 = 1 [ 38 ].

Four fully entangled states known as Bell states exist, and they constitute an orthonormal basis (i.e, a basis in which all of the vectors have the same unit norm and are orthogonal to one another):

• 1. | ψ 00 〉 = 1 2 | 00 〉 + | 11 〉 .
• 2. | ψ 01 〉 = 1 2 | 01 〉 + | 10 〉 .
• 3. | ψ 10 〉 = 1 2 | 00 〉 − | 11 〉 .
• 4. | ψ 11 〉 = 1 2 | 01 〉 − | 10 〉 .

Although there are a variety of ways to create entangled Bell states using quantum circuits, the most basic uses a computational basis as input and includes a Hadamard gate and a CNOT gate (see Figure 5 a).

Quantum circuits of Bell state and Bell measurement. ( a ) Bell state; ( b ) Bell measurement.

The circuit calculation results are displayed in Table 2 .

The results of the Bell states circuit computation.

Input	H	CNOT

In the opposite sense: Bell’s measure is a standard measure with standard outputs i and j corresponds to a measure of the state | ψ i j 〉 . Figure 5 b represents the circuit of Bell measurement.

2.7. Quantum Computer

Quantum computers are processing machines that take advantage of quantum physics properties. This may be extremely beneficial for some tasks, where they can greatly outperform the most powerful supercomputers. A quantum computer can be considered as a co-processor of a traditional computer, as a GPU can be for video games or for training neural networks in deep learning. As shown in Figure 6 , a traditional computer closely control computer operations by triggering at precise rates the qubit operations performed by the quantum gates. This trigger takes into consideration the execution time of the quantum gates as well as the known c o h e r e n c e t i m e of the qubits, i.e., the duration for which the qubits remain in a superposition state. In addition to its classical control computer, the quantum computer includes several components, which we analyze one by one, with the details below:

• Quantum registers are just a collections of qubits. In November 2022, the benchmarked record was 433 qubits, announced by IBM. Quantum registers store the information manipulated in the computer and exploit the principle of superposition allowing a large number of values to coexist in these registers and to operate on them simultaneously;
• Quantum gates are physical systems acting on the qubits of the quantum registers, to initialize them and to perform computational operations on them. These gates are applied in an iterative way according to the algorithms to be executed;
• At the conclusion of the sequential execution of quantum gates, the measurement interface permits the retrieval of the calculations’ results. Typically, this cycle of setup, computation, and measurement is repeated several times to assess the outcome. We then obtain an average value between 0 and 1 for each qubit of the quantum computer registers. The values received by the physical reading devices are therefore translated into digital values and sent to the traditional computer, which controls the whole system and permits the interpretation of the data. In common cases, such as at D-Wave or IBM, which are the giants of quantum computers building, the calculation is repeated at least 1024 times in the quantum computer;
• Quantum chipset includes quantum registers, quantum gates and measurement devices when it comes to superconducting qubits. Current chipsets are not very large. They are the size of a full-frame photo sensor or double size for the largest of them. The size of the latest powerful quantum chip called the 433-qubit Osprey, around the size of a quarter;
• Refrigerated enclosure generally holds the inside of the computer at temperatures near absolute zero. It contains part of the control electronics and the quantum chipset to avoid generating disturbances that prevent the qubits from working, especially at the level of their entanglement and coherence, and to reduce the noise of their operation;
• Electronic writing and reading in the refrigerated enclosure, control the physical devices needed to initialize, update, and read the state of qubits.

The quantum computer’s architecture.

Quantum computers today are built based on atoms (e.g., cold atoms, trapped ions and nuclear magnetic resonance), electrons (e.g., superconducting, silicon and topological), or photon (e.g., linear optics). D-Wave, IBM and Google have all shown significant quantum computer development progress. The D-Wave model is built using the quantum adiabatic technique, which handles issues involving optimization or probabilistic sampling, whereas the IBM model is mostly dealing with non-adiabatic models. Most of those companies provide a quantum computer simulator that runs on a classical computer to test code before executing it on a quantum device. It is possible to use this simulator in either a local environment or the cloud. It cannot handle true quantum states because it is operating on a classical computer, but it is useful for testing code syntax and flow.

2.8. Quantum Algorithms

The creation of quantum algorithms necessitates a higher level of expertise than traditional algorithms and programs. Quantum computers will need the development of a new generation of mathematicians and developers capable of reasoning with the mathematical formalization of quantum programming. Furthermore, these algorithms must be more efficient than those designed for traditional computers or supercomputers. Given that quantum computing employs a distinct method of computation, it is only reasonable to ask what kinds of problems may now be solved in this new environment, even if they were not expected to be solved in a traditional computer. To do this, we must review the theory of complexity.

The complexity theory focuses on the s c a l a b i l i t y and computational cost of algorithms in general and for specific problems. Scalability refers to the time and/or space necessary to increase the volume or complexity of a computation’s goal. Using the Big-O notation, an algorithm that is O ( n 3 ) is considered to be “harder” than one that is O ( n 2 ) , since the former will often affect more operations than the latter, regardless of the time at which these operations are executed. A specific complexity class is composed of problems that share similar characteristics of difficulty. The most significant categories of complexity are discussed below:

• Polynomial time (P): Are issues solvable in a polynomial amount of time. In other terms, a traditional computer is capable of resolving the issue in a reasonable time;
• Non-deterministic Polynomial time (NP): Is a collection of decision issues that a nondeterministic Turing machine might solve in polynomial time. P is an NP subset;
• NP-Complete: X is considered to be NP-Complete only if the requirements here are met: ( i ) X is in NP, and ( i i ) in polynomial time, all NP problems are reducible to X. We assert that X is NP-hard if only ( i i ) is true and not necessarily ( i ) ;
• Polynomial Space (PSPACE): This category is concerned with memory resources instead of time. PSPACE is a category of decision issues that can be solved by an algorithm whose total space utilization is always polynomially restricted by the instance size;
• Bounded-error Probabilistic Polynomial time (BPP): Is a collection of decision issues which may be handled in polynomial time using a probabilistic Turing computer with such a maximum error probability equal to 1/3;
• Bounded-error Quantum Polynomial time (BQP): A decision issue is BQP, if it has a polynomial time solution and has a high accuracy probability. BQP is the basic complexity category of problems which quantum computers may effectively solve. It corresponds to the classical BPP class on the quantum level;
• Exact Quantum Polynomial time (EQP or QP): Is a type of decision issue that a quantum computer can handle in polynomial time with probability 1. This is the quantum counterpart of the P complexity class.

The potential uses of quantum computing vary from decrypting cryptography systems to the creation of novel medications. These applications use quantum algorithms, which are programs that exploit quantum gates on a quantum computer in order to obtain a speedup or even other advantages over traditional algorithms. An important consideration in the creation of quantum algorithms is to ensure that they are more efficient than their counterparts optimized for traditional computers. Theories exist to verify this by evaluating the exponential, polynomial, logarithmic, or linear scaling of the computation time as a measure of the task’s complexity, or a combination of all four. Currently, there are four primary classes of quantum algorithms: s e a r c h a l g o r i t h m s based on those of Deutsch Jozsa [ 39 ] and Grover [ 1 ]; a l g o r i t h m s b a s e d o n Q u a n t u m F o u r i e r T r a n s f o r m s (QFT) such as Shor’s algorithm [ 2 ], which is used to factor integers; q u a n t u m a n n e a l i n g a l g o r i t h m s , algorithms that search for an equilibrium point of a complex system as in neural network training, optimal path search in networks or process optimization; and q u a n t u m s i m u l a t i o n a l g o r i t h m s , which are used to simulate the interactions between atoms in various molecular structures. Quantum chemistry, which simulates the impact of chemical stimulation on a huge amount of atomic particles, is one particularly exciting topic in quantum simulation.

One of the first quantum algorithms invented is that of David Deutsch, called Deutsch Jozsa algorithm [ 39 ], co-invented with Richard Jozsa. This algorithm allows for identifying the function of a “black box” called an “oracle” (a black box that is frequently used in quantum algorithms to estimate functions using qubits), which we know in advance that it will return for all its inputs, either always the same value, 0 or 1, or the values 0 and 1 in equal parts. The algorithm thus makes it possible to know if the function has a balanced output. It is implemented on a set of qubits n, all of the input qubits are set to zero, except one which is initialized to 1, then they are each put in superposition between 0 and 1 using Hadamard gates. The qubits thus have simultaneously all the possible values with 2 n + 1 combinations of values. It is easy to understand why this quantum algorithm is much more efficient than its conventional counterpart. In conventional computation, more than half of the possible input values would have to be sequentially scanned, whereas, in the quantum version, they are all scanned at the same time. This is an example of a strong algorithm that has no known practical use. Moreover, there are classical probabilistic algorithms algorithms that erase a good part of the quantum power gain of the Deutsch–Jozsa algorithm.

Grover’s algorithm is the other popular algorithm [ 1 ], created in 1996. It allows for a fast quantum search in a database. A bit like the Deutsch–Jorza algorithm, it scans a list of elements to find those that verify a specific condition. It also uses the superposition of qubit states to speed up the processing compared to a traditional sequential search. The improvement in performance is significant compared to an unsorted database. Grover’s algorithm also uses an “oracle” or “black box” function that will indicate whether a set of input qubits verifies a search condition or not, such as verifying that a given phone number has been found in a list of phone numbers. In such a case, the function compares the phone number searched and the one submitted to it, to answer one if they are identical and zero otherwise. The black box is a quantum box and will evaluate this function for 2 N registers of qubits at the same time. It will therefore output a one once and zeros elsewhere. The computing time is determined by the square root of the list size, while a classical approach has a computation time proportional to the size of the list. Therefore, going from a time N to N is an interesting gain. This algorithm can then be used to be integrated in other algorithms such as those which allow for discovering the optimal path in a graph or the minimal or maximal number of a series of N numbers.

The quantum Fourier transform (QFT) was invented by Don Coppersmith in 1994 [ 40 ]. It is used in various other algorithms and in particular in Shor’s algorithm, which is a factoring algorithm for integers. The QFT could compute the prime factorization of an N-bit integer in log 2 ( N ) time, whereas the most well-known basic Fourier transform requires N × log ( N ) time. IBM performed one of the initial implementations of Shor’s technique in 2001 using an experimental quantum computer with seven qubits to factor the integer 15. In 2012, Nanyang et al. [ 41 ] claimed factorization of 143 using an NMR adiabatic quantum computer at ambient temperature (300 K). Using a D-Wave 2X quantum computer, the 18-bit number 200 099 successfully factored in April 2016 utilizing quantum annealing [ 42 ]. Late in 2019, an industry collaboration determined that 1,099,551,473,989 equals 1,048,589 times 1,048,601 [ 43 ]. Note that Shor’s algorithm also allows for breaking cryptography using elliptic curves [ 44 ], which compete with RSA cryptography. Incidentally, a part of the cryptography used in the Bitcoin protocol would also pass through the Shor algorithm [ 45 ]. In addition to the purely quantum algorithms (based only on quantum gates), we must indeed add: hybrid algorithms, combining traditional algorithms and quantum algorithms or algorithms based on quantum-classical gates. This is notably the situation involving the Variational Quantum Eigensolver (VQE) [ 46 ], which allows the solution of chemical simulation problems as well as neural network training; and quantum inspired algorithms, which are algorithms for classical computers inspired by quantum algorithms for solving complex problems.

3. Quantum Machine Learning

There are four strategies of how to combine machine learning and quantum computing, based on if one considers the data was created by a classical (C) or quantum (Q) system, and whether the computer that processes data are classical (C) or quantum (Q),(as shown in Figure 7 ).

Four different ways to combine quantum computing with machine learning. Reprinted with permission from Ref. [ 47 ]. 2017, Maria Schuld.

The scenario CC refers to data that is treated traditionally. This is the traditional technique of machine learning; however, in this case, it refers to machine learning using quantum information research-derived approaches. Tensor networks that are designed addressing to quantum many-body processes, have been employed in training neural networks [ 48 ]. In addition, there are various ’quantum-inspired’ machine learning algorithms with varied degrees of quantum theoretical background.

The scenario QC examines how machine learning might aid quantum computing. For instance, if we wish to obtain a complete explanation of the state of a computing device by taking a few measurements, we may analyze the measurement data using machine learning [ 49 ]. There are several applications for machine learning to distinguish either quantum states generated by a quantum source or manipulations carried out by a quantum experiment [ 50 , 51 ].

The scenario CQ uses quantum computing to examine conventional datasets. Observations from classical computers, which include images and text, are supplied to a quantum device for evaluation. The primary objective of the CQ methodology is the development of quantum algorithms to be used in data mining, for which the community has offered a variety of solutions. They might be adaptations of traditional machine learning models to function with quantum algorithms, or they can be entirely novel creations inspired by the characteristics of quantum computing.

The last scenario QQ examines the processing of “quantum data” by a quantum device. There are two possible interpretations of this. The information may be obtained through a quantum experiment involving a quantum system and the subsequent input of those experimental measurements into a different quantum computer. In a second interpretation, a quantum computer simulates the behavior of the quantum system and then uses the state of this system as such an input of a QML algorithm performed on the same computer.

Nowadays, Quantum Machine Learning (QML) algorithms are separated into three distinct strategies. Quantum machine learning algorithms, which are quantum versions of classical machine learning, in addition to algorithms that are implemented on a real quantum computer, including QSVM [ 4 ], Quantum Neural Network [ 52 ] and Quantum Linear Regression [ 8 ]. The second strategy is quantum-inspired machine learning, which leverages the concepts of quantum computing to enhance traditional machine learning algorithms. A few examples of such algorithms include quantum-inspired binary classifier [ 53 ], Helstrom Quantum Centroid which is a quantum-inspired binary supervised learning classification [ 54 ], Quantum-inspired Support Vector Machines [ 55 ], Quantum Nearest Mean Classifier [ 56 ], inspired Quantum K Nearest-Neighbor [ 57 ], quantum algorithms for ridge regression [ 58 ] and Quantum inspired Neural network [ 59 ]. The third strategy, hybrid classical-quantum machine learning algorithms, merges classical and quantum algorithms to improve performance and reduce the cost of learning—for example, using quantum circuit to propose a novel variational quantum classifier [ 60 ], variational quantum SVM and SVM quantum kernel-based algorithm [ 61 ], quantum KNN algorithm [ 62 ], and a hybrid quantum computer-based quantum version of nonlinear regression [ 63 ].

In our study, we concentrate on the CQ scenario. There are two distinct approaches to the development of quantum machine learning models. The first approach involves running traditional machine learning algorithms on quantum computers or simulators in an effort to achieve algorithmic speedups. This approach needs to translate conventional data into quantum data, a process known as q u a n t u m e n c o d i n g . Another approach is to create QML algorithms based on quantum subroutines, including Grover’s algorithm, HHL algorithm, quantum phase estimation, and Variational Quantum Circuit (VQC), which we cover later in detail.

Figure 8 illustrates the processing strategies used in conventional machine learning and QML. In traditional machine learning, data are a direct input to the algorithm, which then analyses the data and generates an output. QML, on the other hand, demands the initial encoding of the data into quantum data. QML receives quantum data as input, processes it, and generates quantum data as output. The quantum data are then converted to conventional data.

Processing techniques of conventional machine learning and quantum machine learning. CD represents classical data and QD represents quantum data.

Quantum Machine Learning requires a more intricate encoding of classical to quantum data than classical machine learning.

3.1. Quantum Encoding

The majority of machine learning models depends on sets of data with { x i } i ∈ [ N ] samples, where x i ∈ R d for every i . Additionally, one requires classical outcomes including labels or classes { y i } i ∈ [ N ] , where y i ∈ R d ′ for every i . It appears that the ability to deal with conventional data will be required for the vast majority of practical applications of quantum machine learning [ 64 ].

In a Hilbert space, there are several strategies for encoding data from conventional data to quantum data. In other words, data encoding requires putting conventional data into a quantum computer as quantum states. We describe three methods. We recommend [ 65 ] for information on different strategies.

3.1.1. Basis Encoding

Basis encoding links a computational basis state for an n-qubit system. Therefore, traditional data should be the binary strings, and encoded quantum state is the bit-wise conversion of a binary string towards the equivalent states of the quantum subsystems. In example, x = 1001 is encoded by the 4-qubit quantum state | 1001 〉 . Furthermore, one bit of classical data are encoded by one quantum subsystem. In some ways, it is the most basic type of computing since every bit is effectively replaced with a qubit, and computations are carried out simultaneously on all bits in a superposition. Consequently, the bit encoding for a vector is the following: m + [ log ( d ) ] qubits could a vector x = ( x 1 , … , x d ) ∈ R d as a quantum superposition of bit strings, where each instance must be a binary string with N bits for the basis encoding. x i = ( b 1 , … , b j , … , b N ) for j = 1 , … , N with b j ∈ { 0 , 1 } :

where m denotes the amount of qubits used for the precision, while d represents the number of samples. To encode a vector x = ( 2 , 3 ) in basis encoding. First, we must transform it to a binary format, with 2 bits, x 1 = 10 , x 2 = 11 . The corresponding basis encoding makes use of two qubits to represent the data as below:

3.1.2. Amplitude Encoding

To employ qubits to represent classical vectors or matrices, the most efficient encoding is by far the amplitude encoding approach. It is the theoretical link between quantum computing and linear algebra that uses quantum features to the maximum. The amplitudes of an n-qubit quantum state | ψ x 〉 as | ψ x 〉 = ∑ i = 1 d x i | i 〉 , with d = 2 n represent a normalized classical d-dimensional set of data x , where x i is the i -th item, and | i 〉 is the i -th computational base state. However, in this case, x i might be any numeric value, such as a floating or integer point. For instance, suppose we want to use amplitude encoding to encode the four-dimensional array x = ( 1.0 , 3.0 , − 2.5 , 0.0 ) . The first step is to normalize this array, which is achieved by setting x n o r m = 1 16 , 25 ( 1.0 , 3.0 , − 2.5 , 0.0 ) . Two qubits are used to encode x n o r m in the corresponding amplitude encoding as follows:

This result state will at the same moment encode the matrix below:

where the first qubit represents the index for such a row, while the second qubit represents the index for such a column.

3.1.3. Qsample Encoding

Qsample encoding is a hybrid scenario of amplitude and basis encoding, and it combines a real amplitude vector with conventional binary probability distributions. Suppose an amplitude vector v = ( v 1 , … , v 2 n ) T that describes an n-qubit quantum state. Sampling a series of bits of size n with a set of discrete probabilities p 1 = | v 1 | 2 ,…, p 2 n = | v 2 n | 2 is comparable to measuring the n qubits. This means that the amplitude vector may be used to characterize the distribution of an a classical discrete random variable [ 66 ]. Taking into account a discrete classical probability distribution over binary representation p 1 , … , p 2 n , the quantum state is:

3.2. Essential Quantum Routines for QML

In this subsection, we discuss a few of the most basic quantum algorithms which aid in the development of quantum machine learning algorithms.

3.2.1. HHL Algorithm

Using a quantum implementation, the Harrow–Hassidim–Lloyd algorithm [ 5 ] consists of solving a linear equation set. Solving a system of linear equations is comparable to the matrix inversion issue. The objective of the matrix inversion problem, with a matrix M and a vector v , is to determine the vector x :

Numerous algorithms for machine learning determine their parameter θ through solving the M θ = v matrix inversion issue, which makes this algorithm essential for quantum machine learning. In general, the matrix M represents the input characteristics of the training data points expressed in the matrix X . The data point matrix X and the targeted vector Y are both used to create the training data point vector v . In linear regression, in which the predicted output is y = θ T x , determining θ is as simple as solving the matrix inversion issue presented below:

thus, M = X T X and v = X T Y in linear regression.

For the HHL algorithm, we must identify one or more operators capable of transforming the state | v 〉 into the solution vector θ . Clearly, M = X T X would have to be included into one of the operators. If M is unitary, we cannot use it as the quantum operator. However, if M is Hermitian, we might assign it to a Hamiltonian denoted by H of a quantum system. As a reminder, a linear operator or matrix H is Hermitian only if its complex conjugate transpose H † is identical to H . Although if M is not Hermitian, a Hermitian operator M ˜ may be defined as shown below:

While M ˜ is now Hermitian, it has the following eigenvalue decomposition:

in which the eigenvectors | u i 〉 provide an orthonormal basis. The vector | v 〉 may be expressed as follows in the orthonormal basis | u i 〉 :

The following is the answer to the inverse problem:

Despite the fact that M ˜ is a Hermitian matrix of spectral decomposition M ˜ = ∑ i λ i | u i 〉 〈 u i | , its inverse is given as follows:

The answer | x 〉 is obtained by putting the value of M ˜ − 1 of Equation ( 18 ) as well as | v 〉 of Equation ( 16 ) into Equation ( 17 ), which can be seen below:

Equation ( 19 ) demonstrates that, if we could move from eigenstates | u i 〉 to 1 λ i | u i 〉 , then would indeed be nearer to the answer. Q u a n t u m p h a s e e s t i m a t i o n (which we discuss later) is one approach for achieving this objective, which used the unitary operator U = e − i M ˜ t upon that state | v 〉 represented as the superposition state of such basis states | u i 〉 , as this will transform the eigenstates | u i 〉 into λ i | u i 〉 . Then, the eigenvalues may be inverted from λ i | u i 〉 to 1 λ i | u i 〉 by a controlled rotation. Let us remember that the state | v 〉 must have a unit norm before a quantum phase estimate could be performed on it. In compared to its classical version, the algorithm asserts exponential gains in speedup for certain issue formulations. The result of the procedure requires O ( ( l o g N ) 2 ) quantum states, but O ( N l o g N ) conventional computing processes.

3.2.2. Grover’s Algorithm

The speed at which database components may be accessed is one of the possible benefits of quantum computing above traditional computing. Such an algorithm is Grover’s algorithm, which may yield a quadratic speedup while searching a database. The algorithm of Grover [ 1 ] employs the amplitude amplification approach [ 67 ] that is used in database search as well as in several other applications.

Assuming we have such a database containing N = 2 n entries, and we wish to find the one indexed by w , which we refer to as the winner. The computational basis states | x 〉 that correspond to n input quantum bits may be used to define the N items. The oracle operates on every one of the computational basis states | x 〉 ∈ { 0 , 1 } n with the output f ( x ) = 1 , while for the other elements, it returns 0. In the paradigm of quantum computing, the oracle U w may be seen as the unitary operator which further operates upon that computational basis state | x 〉 , seen below:

The Oracle has the following impact on the winning element indicated element | w 〉 specified by the computational basis state:

Now that we are already familiar with the oracle, let us examine the stages of Grover’s method. Let | w 〉 represent the superposition of every state:

and the operator,

is called the Grover diffusion operator. We can consider the winner | w 〉 and an extra state | s ′ 〉 which is in the span of | w 〉 and | s 〉 , which is orthogonal to | w 〉 , and which is obtained from | s 〉 by eliminating | w 〉 and rescaling.

This superposition | s 〉 , which is easily produced from | s 〉 = H ⊗ n | 0 〉 n , is the beginning for the amplitude amplification technique, as shown in Figure 9 .

Geometric visualization and the condition of the amplitude of the state | s 〉 .

The left chart corresponds to the two-dimensional plane spanned by orthogonal vectors | w 〉 and | s ′ 〉 which allows for describing the beginning state as | s 〉 = sin θ | w 〉 + cos θ | s ′ 〉 , where θ = arcsin 〈 s | w 〉 = arcsin 1 N . The right picture is a bar chart of the amplitudes of the state | s 〉 .

Geometrically, this relates to a reflection of the state | s 〉 about | s ′ 〉 . This transformation indicates that the amplitude in front of the | w 〉 state turns negative, which in turn implies that the average amplitude (shown by a dashed line in Figure 10 ) has been reduced.

Geometric visualization and the condition of the amplitude after the implementation of the U w operator.

This transformation completes the transformation by matching the state to U s U w | s 〉 , which relates a rotation around an angle θ as shown in Figure 11 .

Geometric visualization and the condition of the amplitude after the implementation of the U s operator.

The state will rotate by r × θ after r implementation of step 2, where r = π 4 2 n ≡ O ( N ) [ 38 ].

• 3. The final measurement will give the state | w 〉 with probability P ( ω ) ≥ 1 − sin 2 ( θ 2 ) = 1 − 1 2 n .

3.2.3. Quantum Phase Estimation

Quantum phase estimation is a quantum algorithm that employs the Quantum Fourier Transform (QFT) to convert information encoded within the phase φ with an amplitude α = | α | e i φ of a state. The QFT accelerates exponentially the process of translating a quantum state encoded vector into Fourier space. It is often utilized in QML algorithms to retrieve the information contained in the eigenvalues of operators which includes details of data points. Phase estimation consists essentially to identify the eigenvalues of such a matrix U , which is represented as the operator U in the quantum circuit U , hence this operator must be unitary. We designate their eigenvectors by | u j 〉 as well as eigenvalues e i θ j , thus U | u j 〉 = e i θ j | u j 〉 . Assuming as inputs an eigenvector and an additional register | u j 〉 | 0 〉 , the method should return | u j 〉 | θ j 〉 . Because the eigenvectors form a basis, it is possible to express every state | ψ 〉 as | ψ 〉 = ∑ j ∈ [ n ] α j | u j 〉 . Phase estimation is therefore particularly convincing due to its potential for use in superposition. The circuit diagram is shown below. Given an eigenvector as well as an extra register | u j 〉 | 0 〉 as input, the algorithm will return | u j 〉 | θ j 〉 . Since eigenvectors constitute a basis, each state | ψ 〉 could be represented as | ψ 〉 = ∑ j ∈ [ n ] α j | u j 〉 . Thus, the most intriguing aspect of phase estimation is its application in superposition. The circuit diagram of the quantum phase estimation is shown in Figure 12 .

Quantum phase estimation circuit. Q F T − 1 is just the inverse QFT.

One has the option of measuring the final output to obtain a classical description of the eigenvalues or retaining it as a quantum state for future computing. Recall that this circuit requires the sequential controlled application of the unitary U . For such U circuits, this can be an expensive operation.

3.2.4. Variational Quantum Circuit

Variational quantum circuits (VQC) [ 68 ] is the method that has attracted the most interest from researchers. It was suggested using the variational quantum eigensolver (VQE) method for quantum chemistry [ 46 ] and the quantum approximation optimization algorithm (QAOA) [ 31 ] for optimization based on classical machine learning. The latter used for a lot of related applications in machine learning [ 27 , 69 , 70 ]. Variational quantum circuit have universal qualities [ 71 , 72 ] and have already shown positive outcomes in real-world tests [ 73 ], but their natures are vastly different. They generally based on the approach shown in Figure 13 . The ansatz is a tiny circuit comprised of numerous gates having adjustable characteristics, including the angle of a gate that controls rotation. The resultant quantum state is then measured, which should provide the correct answers for the intended problem (classification, regression). Initial findings are poor since settings are almost random. The name of this measure referred to as the Loss or the Objective Function. In the end, an optimization is performed on a traditional computer in order to provide a hopefully improved set of parameters for the experiment to test. In addition, this process is repeated until the circuit produces acceptable results.

Representation of a variational quantum circuit optimization scheme.

When performing a VQC, it is necessary to make an estimate of the gradients of such a cost function relative to every parameter. In conventional neural networks, this is typically achieved through backpropagation across analytic procedures. While using VQC, processes become excessively complicated, and we are unable to reach intermediate quantum states unless we first measure them. In the present day, the progressed approach is referred to as the parameter shift rule [ 73 ], and needs to apply the circuit twice for each parameter and measuring its outcome twice. In contrast, traditional deep learning just requires a single forward and backward pass through the network to collect all of the thousand of gradients. The parameter shift rule could be parallelizable over several simulators or quantum devices. However, this might be impractical for a high number of parameters.

Table 3 presents a comprehensive overview of the current QML algorithms and indicates the quantum routines they are based on or have used.

An overview of current quantum machine learning algorithm.

Quantum Routines	QML Applications
HHL algorithm	QSVM [ , ]
	Q linear regression [ ]
	Q least squares [ ]
	QPCA [ ]
Grover’s algorithm	Q k-Means [ ]
	Q K-Median [ ]
	QKNN [ ]
	Q Perceptron Models [ ]
	Q Neural Networks [ ]
Quantum phase estimation	Q k-Means [ ]
Variational quantum circuit	Q decision tree [ ]
	Circuit-centric quantum
	classifiers [ ]
	Deep reinforcement
	learning [ ]

3.3. QML Algorithms

3.3.1. quantum support vector machines.

Support Vector Machines, generally known as SVMs, are a type of supervised algorithm for machine learning that may be used to handle problems involving linear discrimination. The approach involves establishing a hyperplane that differentiates between two different classes of feature vectors. This hyperplane serves as a decision threshold for the further categorization of data and is based on the concept of finding the hyperplane. The SVM is described as aiming to maximize the distance between the hyperplane and the support vectors of the data points that are located nearest to it. Depending on the kernel employed by the SVM method, the objective function is sometimes convex or not. Non-convex functions are often closer to the local maximum; hence, the conventional SVM compromises optimization efficiency and accuracy rate. QSVM uses Grover’s algorithm as a quantum subroutine for reduction. This makes it possible for non-convex cost functions to converge to their global optimal value [ 79 ]. We describe the Quantum SVM algorithm as the following. For clarity, consider linear SVMs with hyperplanes given below:

Recall that c is a constant value while x and θ are vectors. If θ is constrained to a minimum, then the margin may be relied upon to accurately categorize the data. All of that is characterized by the following optimization issue:

subject to one constraint:

In the training data i = { 1 , … , M } and y ( i ) = { − 1 , 1 } , using Lagrange multipliers α ( i ) , the constraint may be included into an objective function, as a consequence, and the problem might be described as follows:

It is important to note that the only non-zero value of α ( i ) is equivalent to the sum of the support vectors x ( i ) . The derivatives listed below are all set to zero order to maximize the objective function F with regard to α ( i ) :

As a result, we can describe weights as:

as well as the simultaneous issue as:

assuming that:

for every i in the training set i = 1 , … , M as well as:

It is possible to introduce nonlinearity into the optimization problem by expanding it to all kernel functions K ( x ( i ) , x ( j ) ) . This kernel approach is used instead of the dot product in the preceding dual problem:

For instance, we may define the Gaussian kernel function by:

This necessitates more Euclidean distance computations. A detailed explanation of each stage of the algorithm is given below:

• 1. kernel function and parameters initialization: Each parameter utilized by a kernel function must have its value initialized. Choose a relevant kernel function for the problem at hand and then generate the corresponding kernel matrix;
• 2. Parameters and classical information represented by quantum states: In this stage, the objective function is segmented, and its components are recorded in qubits. Binary strings may be used to represent the conventional data: x → b = ( b 1 , b 2 , … , b m ) T , (36) with b i = { 0 , 1 } for i = 1 , … , m . Then, the binary strings may be simply converted into k qubit quantum states: | b 1 , b 2 , … , b m 〉 , (37) which form a Hilbert space of 2 k dimensions covered by basis { | 00 … 0 〉 , | 10 … 0 〉 , … , | 11 … 1 〉 } ;
• 3. The quantum minimization subroutine examines objective function space: The Grover technique determines the optimal value of α ( i ) that resolves for θ and c by searching the space of all possible objective functions. By first generating a superposition of all potential inputs to a quantum oracle O expressing the objective function, this procedure achieves a global minimum for the SVM optimization problem. This subroutine’s measurement yields the answer with a high degree of probability.

The Grover approach decreases the temporal complexity of the given SVM optimization problem from O ( N ) to O ( N ) , in which N is the training vector’s dimension, and provides a global minimum. The computation of a kernel matrix is one of the most time-consuming aspects of any SVM algorithm, with a computational complexity of O ( M 2 N ) . The approach has the same limitations as that of the quantum subroutine GroverOptim, namely that the algorithm could not produce acceptable results due to quantum noise. It is assumed that the objective function of SVM is provided as an input to the algorithm by a quantum oracle. Another quantum technique for SVM, introduced in [ 4 ], demonstrates an unconstrained exponential speed-up, as we shall discuss below.

3.3.2. Quantum Least Square SVM

The quantum variant of the Least Square SVM is a quantum machine learning breakthrough, in which Rebentrost et al. [ 4 ] obtained a significant exponentially speedup gain in the formulation of support vector machine. This algorithm transforms the optimization issue into such a linear equation system that includes the kernel matrix in handling the optimization model. By handling the least squares method and accelerating the kernel matrix computations, we obtain a significantly more efficient method for solving the linear equations system. We use quantum advantages in the following areas to improve the efficiency of the SVM:

• Quantum random access memory (QRAM) data translation: Preparing the collected data as input into the quantum device for computation is among the difficult tasks in QML. QRAM aids in transforming a collection of classical data into its quantum counterpart. QRAM requires O ( l o g 2 d ) steps to retrieve data from storage in order to reconstruct a state, with d representing the feature vector’s dimension;
• Computation of the kernel matrix: The kernel matrix is mostly determined by the examination of the dot product. Therefore, if we obtain speedup benefits of the dot product performance in the quantum approach, this will result in an overall speedup increase in the computation of the kernel matrix. With the use of quantum characteristics, the authors of [ 5 ] provide a quicker method for calculating dot products. A quantum paradigm is also used for the computation of the normalized kernel matrix inversion K − 1 . As previously said, QRAM requires only O ( l o g 2 d ) steps to request for recreating a state, hence a simple dot product using QRAM requires O ( ϵ − 1 l o g 2 d ) steps, where ϵ represents a desired level of accuracy;
• Least square formulation: The quantum implementation of the exponentially faster eigenvector performance makes the speedup increase conceivable during the training phase in matrix inversion method and non-sparse density matrices [ 5 ].

The formulation for the least square SVM is as follows:

using A ^ = A T r A Normalized T r A , and T r A represents a trace of A . The aim will be solving the optimization issue A ^ ( | b , α → 〉 ) = | y → 〉 , where b and α → are parameters, and K denotes the kernel matrix.

3.3.3. Quantum Linear Regression

The aim of any regression issue is to make an accurate prediction of the continuous value of a target variable y i ∈ R , based on a collection of input characteristics x ( 1 ) , x ( 2 ) … x ( N ) , which may be expressed as an N-dimensional input data vector x ∈ R N . It is assumed in linear regression that the output is a linear composition of the input characteristics and an unavoidable error factor ϵ i , as shown below:

The parameters of the model we would like to learn are the θ i values relating to each feature and the intercept b . If the parameters θ i , where i ∈ { 1 , 2 , … N } are represented with such a vector θ ∈ R , the linear connection from Equation ( 39 ) may therefore be simplified as follows:

The phrase y i / x i i represents the value of y i as a function of x i . Therefore, ϵ i would be the fundamental component which has zero association with the input characteristics, and, as a result, cannot be learned. Nevertheless, given x i , we can precisely define the phrase θ T x i + b . Assuming that the error ϵ i has a normal distribution having zero mean and limited standard deviation σ i , the following expression may be written:

and θ T x i + b was indeed constant based on the value within the feature vector x i ; hence, we may affirm:

Given the input feature, the target label y i follows a normally distributed with mean θ T x i + b and standard deviation σ . As can be seen below, in linear regression, the conditional mean of the distribution is used to make predictions:

Minimizing the square of the error term ϵ i at every data point enables the identification of the model parameters θ and b . The bias factor b may be used as a parameter through the parameter vector θ associated with the constant feature of 1 for convenience of notation. This results in the prediction y ^ i = θ T x i where θ and x i represent N + 1 -dimensional vectors. Through this reduction in complexity, the equation system describing the M data points may be expressed in matrix notation below:

Equation ( 44 ) may be rewritten as follows using a matrix representation of the input feature vectors X ∈ R M × ( N + 1 ) and a vector representation of the prediction Y ^ i ∈ R M :

Therefore, if we let the vector Y ∈ R M represent the actual targets y i in all M sets of data, we can calculate the error vector ϵ ∈ R as below:

The loss function may be expressed also as the average of the squared errors in the predictions over all points in the data:

The parameter may be determined by minimizing the loss L ( θ ) for a range of values of θ . The minima may be found by setting the gradient of the loss L ( θ ) relative to θ to zero vector, as illustrated below:

The matrix ( X T X ) may be thought of as the Hamiltonian of a quantum system due to its Hermitian character. Using the HHL technique, we may solve the matrix inversion issue posed by Equation ( 48 ) in order to obtain the model parameter θ .

3.3.4. Quantum K-Means Clustering

Grover’s search algorithm and the Euclidean distance computation approach may be used to provide the quantum equivalent of conventional k-means clustering. The processes are identical to those of the traditional k -means algorithm, only with the exception that quantum routines rather than conventional ones are used to execute each step. The steps are detailed below.

• 1. Initialization: Set the k cluster u 1 , u 2 , … , u k ∈ R n by using heuristic comparable to that of the traditional k -means algorithm. For instance, k data points may be randomly selected as the first clusters;
• (a) In every piece of data, x i ∈ R n defined with its magnitude | | x → i | | 2 saved conventionally as well as the unit norm | x i 〉 saved like a quantum state, the distance is computed by using quantum Euclidean distance computation procedure with every one of the k cluster centroids: d ( i , j ) = | | ( x i − u j ) | | 2 = 4 Z ( P ( | 0 〉 ) − 0.5 ) , (49) with j ∈ { 1 , 2 , … k } ;
• (b) Apply the search technique developed by Grover to allocate every x i in the data set to a single k clusters. As seen below, the oracle implemented in Grover’s search method must be capable of taking the distance d ( i , j ) and then allocate the proper cluster c i according to the formula below: c i = a r g m i n j | | ( x i − u j ) | | 2 c i ∈ { 1 , 2 , … k } ; (50)
• (c) The mean of each cluster is determined after assigning each piece of data x i to its cluster c i ∈ { 1 , 2 , … k } : u j = 1 N j ∑ c i = j x i , (51) where N j represents the total number of data that might be assigned to cluster j .

The method converges when the clusters of data points no longer change with each iteration. Conventional k -means clustering does have an iteration complexity equal to O ( M N k ) ). For each data point, the computational complexity of the distance to a cluster is O ( N ) , wherein N represents the number of features. The complexity is O ( N k ) for each data point, as there are k clusters. Moreover, the total complexity for every iteration is O ( M N k ) , as the complexity for each of the M points of data are O ( N k ) . The advantage of the quantum k-means implementation is that the complexity of computing the quantum Euclidean distance between every data point in a cluster is just M l o g ( N ) k for a high value of a feature size N . Notably, for conventional and quantum k-means, the complications of allocating every data point towards the right cluster using distance minimization are not taken into account. In this aspect, if built appropriately, Grover’s technique, which is used to allocate data points to its respective clusters, may give an additional speedup.

3.3.5. Quantum Principal Component Analysis

The classical Principal component analysis (PCA) is a crucial dimensionality reduction approach. We might claim that PCA works by transposing the covariance matrix of the data, C = ∑ j u → u → j T , onto its diagonal. The covariance matrix summarizes how the various data elements are related to one another. To write the covariance matrix in terms of its eigenvectors and eigenvalues, we write C = ∑ j e k v → k v → k † , wherein e k represents the eigenvalues corresponding to the eigenvectors v k . Principal components refer to the few eigenvalues that are relatively big compared to the rest. Therefore, each of the primary components is regarded as a new feature vector.

The traditional PCA technique has a runtime complexity of O ( d 2 ) , wherein d corresponds to the size of the Hilbert space. For quantum PCA [ 14 ], a quantum state is transferred into a randomly selected data vector using QRAM. ρ = 1 N ∑ j | u j 〉 〈 u j | is the density matrix of the resultant state, with N being the cardinality of the input vector collection. Applying density matrix exponentiation in conjunction with the continuous sampling of the data and quantum phase estimation approach, we may deconstruct the input vectors into their principal components. The quantum PCA method has a runtime complexity of O ( ( l o g d ) 2 ) .

4. ML vs. QML Benchmarks

In this section, we perform the Variational Quantum Classifier and compare it with several classical classifiers; next, we implement QSVM and compare it with the classical SVM, and then the implementation of the Quantum Convolutional Neural Network is discussed in the last sub-section.

4.1. Variational Quantum Classifier

The Variational Quantum Classifier (VQC) is based on the use of a function f ( x , θ ) = y which can be implemented in a quantum computer using a circuit denoted as S x in order to encode the input data x toward a quantum state and especially as amplitudes of the state, then a quantum circuit denoted as U θ , finally a one simple qubit measurement. This latter measurement yields the likelihood of the VQC predicting ’0’ or ’1’, which may be used to determine the prediction of a binary classification. The circuit parameters ( θ ) of this classification are also trainable, and a variational technique may be employed to train these parameters [ 77 ]. The four steps of VQC are shown in Figure 14 and explained below.

The classification with the quantum classifier consists of four phases, each represented by a distinct color, and can be examined from three different perspectives: a formal mathematical diagram, a quantum circuit diagram, and a graphical neural network diagram [ 77 ].

• State preparation: To be able to encode classical data into quantum states, we use particular operations to help us work with data in a quantum circuit. As mentioned earlier, quantum encoding is one these methods that consists of representing classical data in the form of a quantum state in Hilbert space employing a quantum feature map. Recall that a feature map is a mathematical mapping that allows us to integrate our data into higher dimensional spaces, such as quantum states in our case. It is similar to a variational circuit in which the parameters are determined by the input data. It is essential to emphasize that a variational circuit depends on parameters that can be optimized using classical methods;
• The model circuit: The next step is the model circuit, or the classifier in precise terms. φ ′ is generated using a parameterized unitary operator U θ applied to the feature vector noted as φ ( x ) which became a vector of a quantum state in an n-qubit system (in the Hilbert space ). The model uses a circuit that is composed of gates which change the state of the input and are built on unitary processes, and they depend on external factors that can be adjusted. U θ translates φ ( x ) into another vector φ ′ with a prepared state | φ ( x ) 〉 in the model circuit. U θ is comprised of a series of unitary gates;
• Measurement: We take measurements in order to obtain information from a quantum system. Although a quantum system has an infinite number of potential states, we can only recover a limited amount of information from a quantum measurement. Notice that the number of qubits is equal to the amount of results;
• Post-process: Finally, the results were post-processed including a learnable bias parameter and a step function to translate the result to the outcome 0 or 1.

4.1.1. Implementation

The architecture that we have implemented is inspired from [ 77 ], as we have already mentioned. The goal is to encode the real vectors as amplitude vectors (amplitude encoding) and training the model to detect the first two classes of the Iris dataset.

• Dataset: Our classification data sets made up of three sorts of irises (Setosa, Versicolour, and Virginica), and containing four features that are Sepal Length, Sepal Width, Petal Length and Petal Width. In our implementation, we used the two first classes:
• - VQC: The Variational Quantum Classifiers commonly define a “layer”, whose fundamental circuit design is replicated to create the variational circuit. Our circuit layer is composed of a random rotation upon each qubit, and also a CNOT gate that entangles each qubit with its neighbor. The classical data were encoded to amplitude vectors via amplitude encoding;
• - SVC: A support vector classifier (SVC) implemented by the sklearn Python library;
• - Decision Tree: Is a non-parametric learning algorithm which anticipates the target variable through learning decision rules;
• - Naive Bayes: Naive Bayes classifiers utilize Bayes theory with the assumption of conditional independence in between each pair of features;
• Experimental Environment: We use the Jupyter Notebook and PennyLane [ 80 ] (A cross-platform Python framework for discrete programming of quantum computing) for developing all the codes and executing them on IBM Quantum simulators [ 81 ]. We implemented three classical Scikitlearn [ 82 ] algorithms to accomplish the same classification task on a conventional computer in order to compare their performance with that of the VQC. We also used the end value of the cost function and the test accuracy as metrics for evaluating the implemented algorithms.

4.1.2. Results

As it can be plainly observed from the Table 4 , our VQC works slightly better than the best result obtained with the SVC in both terms of accuracy and cost function value. The probability of a model guessing the correct class in the classical example is less than 0.96, but the probability of the quantum classifier is 1 with the value of the cost function equal to 0.23, which shows that the quantum classifier made small errors in the data compared to SVC and Decision Tree.

Result of the classification algorithms for the Iris dataset.

Metric	VQC	SVC	Decision Tree	Naive Bayes
Accuracy	1	0.96	0.96	0.96
Cost	0.2351166	0.0873071	0.0906691	1.381551

One may assume that the effort required to employ quantum algorithms is exaggerated. However, we have to look at the whole process, in which we reduced the dimension of the data set in order to handle it by only two qubits in order to use a smaller circuit depth to prepare quantum states. Despite this, the results are promising.

4.2. SVM vs. QSVM

Quantum Support Vector Machine (QSVM) is a quantum variant of the standard SVM algorithm that uses quantum principles to perform computations. QSVM employs the advantages of quantum hardware and quantum software to enhance the performance of classic SVM algorithms that perform on classical computers with GPUs or CPUs. The initial procedure QSVM is to encode the conventional data which contains specific categories (class, features, dimension, etc.) giving the information about the data we wish to classify. Current quantum hardware functions are yet to achieve full capability as there is a limited number of qubits accessible. Therefore, we need to decrease the features of the data to render it compatible with the available qubits. The principal component analysis (PCA) is typically employed in machine learning for this kind of procedure. Next, the classical data are required to be mapped towards quantum input in order to be treated by the quantum computer. These mapped data are called a feature map which operates as a quantum feature for classical data. Finally, the proper machine learning algorithm needs to implemented to attain the best classification result. This implementation covers many processes including dividing the data into training and testing sets, determining the amount of qubits to be employed, defining the classes of data. Additionally, we need to define the algorithm as well as parameters for how many iterations this should be carried out with the depth of the circuit.

4.2.1. Implementation

The objective of this implementation is to compare the performances of the classical SVM and the QSVM which is implemented on a dataset that represents the real world using a quantum computer.

• Breast cancer dataset: The Wisconsin Diagnostic Breast Cancer dataset (WDBC) of UCI machine learning repository is a classification dataset that includes breast cancer case metrics. There are two categories: benign and malignant. This dataset contains information on 31 characteristics that define a tumor, among which are: average radius, mean perimeter, mean texture, etc., and a total of 569 records and 31 features;

The set of data (20 total) after performing PCA.

The needed number of qubits is proportional to the data dimensionality. By altering the angle of unitary gates to a certain value, data are encoded. QSVM uses a Quantum processor to estimate the kernel in the feature space. During the training step, the kernel is estimated or computed, and support vectors are obtained. However, in applying the Quantum Kernel method directly, we should encode our training data and test data into proper quantum states. Using Amplitude Encoding, we may encode the training samples in a superposition inside one register, while test examples can be encoded in a second register.

4.2.2. Results

We have implemented SVM on the breast cancer dataset from the Scikit learn library in a classical computer using SVM as well as using QSVM on a quantum simulator in the IBM cloud using its quantum machine learning library Qiskit [ 81 ], in order to compare their performances.

As we can observe from Figure 16 , the QSVM has predicted accurately the classes of our test data, and we obtained an accuracy around 90%. Notice that, on the diagonal of the kernel matrix, we have only black squares, which means that each point is at a distance of zero from itself. In addition, what we are seeing in the kernel matrix in Figure 16 and Figure 17 , is the calculated distance of the kernel in the space with higher dimensions. Thus, we may say that, with QSVM, our dataset can simply classify, due to the quantum feature map method which encodes data in a space with a higher dimension.

Kernel matrix of QSVM, with an accuracy of around 90%.

Kernel matrix of SVM, with an accuracy of around 85%.

4.3. CNN vs. QCNN

Convolutional Neural Networks (CNNs) are a prominent model in computer vision that has gained a ton of potential for different machine learning tasks notably in the area of image recognition. The capacity of such networks to retrieve features from input in a typical hierarchical structure provides the majority of their advantages. Several transformation layers, mainly the convolutional layer that provides its name to the model, are employed to retrieve these features. To perform the CNN model on a quantum computer, we implement another kind of transformation layer named quanvolutional layer or quantum convolution utilized in Quanvolutional Neural Networks model (QNNs), which is introduced by Henderson et. al. [ 29 ]. Quanvolutional layers perform on data input by encoding it through a series of arbitrary quantum circuits, in a manner that is equivalent to the task of the aleatory convolutional filter layers. In this subsection, we briefly review the architectural design of Convolutional Neural Networks (CNNs) and then the architectural design of Quanvolutional Neural Networks (QNNs) that are also known as Quantum Convolutional Neural Networks (QCNNs). Then, we evaluated the performance advantage of quantum transformations by making a comparison between the CNN and QNN models based on the MNIST dataset.

Convolutional neural networks (CNNs) are a specialized sort of neural networks, built primarily for time series or image processing. They become presently the most frequently used models for image recognition applications. Their abilities have indeed been applied in several sectors such as gravitational wave detection or autonomous vision. Despite these advances, CNNs struggle from a computational limitation which renders deep CNNs extremely pricey in reality. As Figure 18 illustrates, a convolutional neural network generally consists of three components even though the architectural implementation varies considerably:

Representation of a CNN’s architecture. Source: Mathworks.

• 1. Input: The most popular input is an image, although significant work has also been carried out on so-called 3D convolutional neural networks which can handle either volumetric data (three spatial dimensions) or videos (two spatial dimensions + one temporal dimension). For the majority of the implementations, the input needs to be adjusted to correspond to the specifics of the CNN used. These include cropping, lowering the size of the image, identifying a particular region of interest, and also normalizing pixel values to specified regions. Images, and even more widely layers of a network, may be represented as tensors. The tensor is a generalization of a matrix into extra dimensionality. For example, an image of a height H and a width W may indeed be visualized as just a matrix in R H × W , wherein every pixel represents a greyscale ranging between 0 and 255. Furthermore, all three channels in color RGB (Red Green Blue) should be taken into account, simply layering 3 times the matrix for every color. A whole image is thus viewed as a three-dimensional vector in R H × W × D wherein D represents the number of channels;
• - Convolution Layer: Each l th layer is combined by a collection filter named kernels. The result of this procedure would be the ( l + 1 ) th layer. The convolution using a simple kernel may be considered to be like a feature detector, which will screen through all sections of the input. If a feature described by a kernel, for example, a vertical border, is present through some area of the input, it will be highly valuable at the corresponding point of the outcome. The outcome is known as the feature map of the whole convolution;
• - Function: Just like in normal neural networks, we add certain nonlinearities also named activation functions. These functions are necessary for a neural network in order to be capable of learning any function. As in implementation of a CNN, every convolution is frequently followed by a Relu (Rectified Linear Unit function). This is a basic function that sets all negative numbers of the output to zero, then leaves the positive values as they are;
• - Pooling Layer: The downsampling method that reduces the dimensions of the layer, particularly optimizing the calculation. Furthermore, it provides the CNN the capability to learn a form invariant to lower translations. Almost all of the cases, either we use a Maximum Pooling or perhaps an Average Pooling. Maximum Pooling consists of swapping a subsection of P × P components just by another with the biggest value. Average Pooling achieves this by averaging all numbers. Note that the number of a pixel relates to how often a certain feature is represented in the preceding convolution layer;
• 3. Classification/Fully Connected Layer: Following a specific set of convolution layers, the inputs had been properly handled such that we may deploy a fully connected network. The weights link every input to every output, wherein inputs are all components of the preceding layer. The final layer must include a single node for each possible label. The node value may be read as the probability that the input image belongs to the specified class.

The Quanvolutional Neural Networks (QNNs) are essentially a variant of classical convolutional neural networks with an extra transformation layer known as the quanvolutional layer, or quantum convolution that is composed of quanvolutional filters [ 29 ]. When applied, the latter filters to a data input tensor; then, this will individually generate a feature map by changing spatially local subsections of this input. However, unlike the basic handling data element by element in matrix multiplication performed by a traditional convolutional filter, a quanvolutional filter transforms input data using a quantum circuit that may be structured or arbitrary. In our implementation, we employ random quantum circuits as proposed in [ 29 ] for quanvolutional filters rather than circuits with a specific form, for simplicity and to create a baseline.

This technique for converting classical data using quanvolutional filters can be formalized as follows and illustrated in Figure 19 :

( A ) represents a quanvolutional layer inside a network architecture. The quanvolutional layer has a series of quanvolutional filters (three in this case) that transform the entered data to various outcome feature maps. ( B ) represents the transformation of conventional data input and output of an arbitrary quantum circuit within the quanvolutional filter [ 29 ].

• 1. Let us simply begin with a basic quanvolutional filter. The latter filter employs the arbitrary quantum circuit q that accepts as inputs subsections of images of dataset a u . Each input is denoted by the letter u x , with each u x being a two-dimensional matrix of length n -by- n , where n is greater than 1;
• 2. Despite the fact that there are a variety of methods for “encoding” u x as an initial state of q , we chose one encoding method e for every quanvolutional filter, and we define the resulting state of this encoding with i x = e ( u x ) ;
• 3. Thereafter, the application of the quantum circuit q to the beginning state i x , and the outcome of the quantum computing was indeed the quantum state o x , as defined by the relation o x = q ( i x ) that also equals q ( e ( u x ) ) ;
• 4. In order to decode the quantum state o x , we use d which is our decoding method that converts the quantum output into classical output using a set of measurements, which guarantees that the output of the quanvolutional filter is equivalent to the output of a simple classical convolution. The decoded state is described by f x = d ( o x ) with d ( q ( e ( u x ) ) ) in which f x represents a scale value;
• 5. Lastly, we denote the full transformation achieved by the ’quanvolutional filter transformation’ [ 29 ] by Q of a data point u x , which is also described as f x = Q ( u x , e , q , d ) . Figure 19 B represents one basic quanvolutional filter, showing the encoding, the applying circuit and the decoding process.

4.3.1. Implementation

The aim of this implementation is to demonstrate the practicality of quanvolutional layers included in a classical CNN model, the feasibility to employ this quanvolutional technique using actual world data sets, and the possibility of using features created by the quanvolutional transformation.

• Dataset: We used a subset of the MNIST (Modified or Mixed National Institute of Standards and Technology) dataset, which includes 70,000 handwritten 28 by 28 pixels in grayscale;
• - The CNN model: We used a simple model: Fully-connected layer containing ten output nodes and then a final activation function softmax in a pure classical convolutional neural network;
• - The QNN model: A CNN with one quanvolutional layer seems to be the simplest basic quanvolutional neural network. The single quantum layer will be the first, and then the rest of the model is identical to the traditional CNN model;
• Experimental Environment: The Pennylane library [ 80 ] was used to create the implementation, which was then run on the IBM quantum computer simulator QASM;
• - A quantum circuit is created by including some small section of the input image, in our case a square of 2 × 2 . A rotation encoding layer denoted by R y (with angles scaled by a factor π );
• - The system performs a quantum computation associated with a unit U. A variational quantum circuit or, quite generally, a randomized circuit could generate this unit;
• - The quantum system is measured using a computational basis measurement, which gives a set of four classical expectation values. The outcomes of the measurements can eventually be post-processed in a classical way;
• - Each value is translated into a distinct channels of one output pixel, as in a classical convolution layer;
• - In repeating the technique on different parts, the whole input image can be scanned, thus obtaining an output object structured as a multi-channel;
• Other quantum or classical layers can be added after the quanvolutional layer.

4.3.2. Results

Before analyzing the performance of the QNN model and traditional CNN results, we should first confirm that the model works as planned; the addition of the quanvolutional layer to the model has resulted in a highest accuracy, and the more the training iterations there are, the more the accurate the model becomes. The value of the loss function in the QNN models is quite low, which shows that our model has fewer errors during testing. As shown in Table 5 below, the QNN has a slightly higher accuracy than the CNN which indicates that our QNN model has well predicted our test data which are not used in the training of the model. We can conclude that the generated quantum features were effective in constructing features for the MNIST data set for classification purposes.

Results of the benchmarking experiments.

Algorithm	Loss Function	Test Accuracy
	1.0757	0.6667
	0.9882	0.7000

In Figure 20 , we clearly observe the reduction of the sampling of the resolution and certain local deformations generated by our quanvolutional layer. In addition, the general shape of the input image is preserved, as expected for a convolution layer.

Under each input, the four outcome channels produced by our quantum convolution were shown in grayscale images.

Figure 21 displays the outcomes of this implementation. Our QNN model typically provides superior learning performance compared to the CNN model. The presented results prove that the quantum convolution layer might boost learning performance.

Comparative performance of the QCNN model and the CNN model.

5. General Discussion

As shown in the results above, the three quantum algorithms outperformed their classical counterparts in terms of accuracy and cost function value. However, it is indeed challenging to affirm that a QML algorithm will ever be better compared to a classical machine learning algorithm through practice since a quantum computer is evolved in noisy intermediate-scale quantum (NISQ) and small-scale quantum devices, which inhibits us to use a limited amount of qubits and few features, and huge data processing on quantum devices is impracticable due to the loss of a large amount of important information. QML has a number of challenges that are required to be solved on both the hardware and software levels. Quantum computers with a high-qubit-count and interface devices, such as quantum random access memory (qRAM), which enables classical information to be recorded in quantum states structure, represents the biggest and most significant challenges. Small scale quantum computers with 50–150 qubits are commonly accessible through quantum cloud computing, and their hardware is distinct; we can observe ion-trapped devices (IonQ) and both superconducting devices (IBM or Rigetti). Additionally, there are devices consisting of topological qubits, NV center (diamond), photons, quantum dots and neutral atoms. When it comes to physically implementing the quantum devices, each company decides one or more technologies. Each has benefits and drawbacks, and there is no agreement or dominance of one in the literature. However, due to the size of these devices, the complexity of their implementation, and their ongoing development, their everyday access is not yet feasible. An upgrade in quantum hardware will enable an improvement in the performance of applied algorithms. Because the the potential number of output labels is proportional to the amount of qubits in the device, most of the used algorithms, such as image classification using QCNN, are constrained by the number of qubits. We may also find a vast selection of quantum simulators on many platforms, which enable the testing of quantum computers as if they were real and even imitate their noise.

6. Conclusions and Perspectives

This article reviews a selection of the most recent research on QML algorithms for a variety of issues which are more accurate and effective than classical algorithms in classical computing, especially focusing on the quantum variant of certain supervised machine learning algorithms that rely on the VQC. In addition, we discuss numerous ways for mapping data into quantum computers. We covered approaches of quantum machine learning such as quantum sub-processes. In addition, then, we compared the performance of various QML algorithms such as QSVM, VQC, and QNN with that of its classical counterparts.

The QSVM algorithm exceeded the classical SVM in performance and speed up, but when it performed on a small subset of the dataset. Most quantum machine learning techniques are at some point restricted by the absence of an appropriate quantum RAM (QRAM) which facilitates the mapping of classical input to a quantum computer. The number of practical machine learning algorithms in the area of QML is expected to rise as QRAM implementations reach a stable state.

The VQC obtains a greater advantage over certain classical classifiers when implemented on a quantum computer with a smaller circuit depth, employing only two qubits to encode a subset of the dataset. Furthermore, we aim for a similar result on a large dataset with the existence of large number of qubits.

The result produced by the QNN demonstrated that the model can be a solution in several classification tasks, and it is a more efficient and effective learning model when employed with a classical CNN model. Moreover, the QNN model may also predict highly efficient results in much more sophisticated and large-scale training using quantum computers of the NISQ (Noisy Intermediate-Scale Quantum) era.

In conclusion, comprehensive benchmarks on large datasets are needed to systematically examine the influence of growing input data. In addition, in the near-term, the quantum encoding (feature maps) approach is a strong and theoretically interesting approach to think about in order to successfully implement quantum machine learning algorithms.

As a future work, we are currently developing new quantum machine learning algorithms that are able to handle a large actual world datasets which can be handled on currently quantum computers. Our next objective is to examine the implementation of classical machine learning models on quantum computers.

Funding Statement

This research received no external funding.

Institutional Review Board Statement

Not applicable.

Data Availability Statement

Conflicts of interest.

The authors declare no conflict of interest.

Disclaimer/Publisher’s Note: The statements, opinions and data contained in all publications are solely those of the individual author(s) and contributor(s) and not of MDPI and/or the editor(s). MDPI and/or the editor(s) disclaim responsibility for any injury to people or property resulting from any ideas, methods, instructions or products referred to in the content.

Subscribe to the PwC Newsletter

Join the community, add a new evaluation result row, quantum machine learning.

97 papers with code • 2 benchmarks • 1 datasets

Benchmarks Add a Result

--> --> -->

Trend	Dataset	Best Model	Paper	Code	Compare
		Quntum Neural Network
		Best Model

Latest papers

Multi-scale feature fusion quantum depthwise convolutional neural networks for text classification.

cyx617/Text-Classification-MSFF-QDConv-Model • 22 May 2024

We also show the advantages of our quantum model over its classical counterparts in its ability to improve test accuracy using fewer parameters.

Feature Importance and Explainability in Quantum Machine Learning

LukePower01/ml-to-qml • 14 May 2024

This article explores feature importance and explainability insights in QML compared to Classical ML models.

Quantum Patch-Based Autoencoder for Anomaly Segmentation

Quantum Machine Learning investigates the possibility of quantum computers enhancing Machine Learning algorithms.

Guided-SPSA: Simultaneous Perturbation Stochastic Approximation assisted by the Parameter Shift Rule

The computational complexity, in terms of the number of circuit evaluations required for gradient estimation by the parameter-shift rule, scales linearly with the number of parameters in VQCs.

On Optimizing Hyperparameters for Quantum Neural Networks

sabrinaherbst/hyperparameters_qnn • 27 Mar 2024

The increasing capabilities of Machine Learning (ML) models go hand in hand with an immense amount of data and computational power required for training.

Better than classical? The subtle art of benchmarking quantum machine learning models

Benchmarking models via classical simulations is one of the main ways to judge ideas in quantum machine learning before noise-free hardware is available.

Guided Quantum Compression for Higgs Identification

To ameliorate this issue, we design an architecture that unifies the preprocessing and quantum classification algorithms into a single trainable model: the guided quantum compression model.

Élivágar: Efficient Quantum Circuit Search for Classification

Although recent Quantum Circuit Search (QCS) methods attempt to search for performant QML circuits that are also robust to hardware noise, they directly adopt designs from classical Neural Architecture Search (NAS) that are misaligned with the unique constraints of quantum hardware, resulting in high search overheads and severe performance bottlenecks.

Quantum Denoising Diffusion Models

In recent years, machine learning models like DALL-E, Craiyon, and Stable Diffusion have gained significant attention for their ability to generate high-resolution images from concise descriptions.

QuantumSEA: In-Time Sparse Exploration for Noise Adaptive Quantum Circuits

To address these two pain points, we propose QuantumSEA, an in-time sparse exploration for noise-adaptive quantum circuits, aiming to achieve two key objectives: (1) implicit circuits capacity during training - by dynamically exploring the circuit's sparse connectivity and sticking a fixed small number of quantum gates throughout the training which satisfies the coherence time and enjoy light noises, enabling feasible executions on real quantum devices; (2) noise robustness - by jointly optimizing the topology and parameters of quantum circuits under real device noise models.

IEEE Account

• Change Username/Password
• Update Address

Purchase Details

• Payment Options
• Order History
• View Purchased Documents

Profile Information

• Communications Preferences
• Profession and Education
• Technical Interests
• US & Canada: +1 800 678 4333
• Worldwide: +1 732 981 0060
• Contact & Support
• About IEEE Xplore
• Accessibility
• Terms of Use
• Nondiscrimination Policy
• Privacy & Opting Out of Cookies

A not-for-profit organization, IEEE is the world's largest technical professional organization dedicated to advancing technology for the benefit of humanity. © Copyright 2024 IEEE - All rights reserved. Use of this web site signifies your agreement to the terms and conditions.

• Quantum Computing

Quantum Machine Learning

• Publisher: De Gruyter
• ISBN: 978-3-11-067070-7

• VŠB-Technical University of Ostrava

• RCC Institute of Information Technology

• Amity University

• Cooch Behar Government Engineering College

Discover the world's research

• 25+ million members
• 160+ million publication pages
• 2.3+ billion citations

• Richard Kueng

• Adrián Pérez-Salinas
• Recruit researchers
• Join for free
• Login Email Tip: Most researchers use their institutional email address as their ResearchGate login Password Forgot password? Keep me logged in Log in or Continue with Google Welcome back! Please log in. Email · Hint Tip: Most researchers use their institutional email address as their ResearchGate login Password Forgot password? Keep me logged in Log in or Continue with Google No account? Sign up

More From Forbes

The future of ai: unleashing the power of quantum machine learning.

• Share to Facebook
• Share to Twitter
• Share to Linkedin

Exploring Quantum Computing and Artificial Intelligence - Joshua Lamerton , Tech Innovator and AI Enthusiast.

Artificial intelligence (AI) has become integral to our daily lives, from virtual assistants like Siri to personalized recommendations on Netflix. As AI technology advances, quantum machine learning has emerged as a groundbreaking innovation with the potential to revolutionize the world.

What Is Quantum Machine Learning?

Quantum machine learning (QML) combines the principles of quantum computing with machine learning. Unlike classical computers, which use bits to process information, quantum computers utilize quantum bits or qubits. Due to superposition and entanglement, these qubits can exist in multiple states simultaneously, enabling quantum computers to process massive datasets to solve complex problems at high speeds.

Why Is QML A Game Changer?

Quantum machine learning significantly enhances existing machine learning algorithms, improving their accuracy, effectiveness and efficiency. By leveraging quantum processing, complex calculations can be solved at unprecedented speeds and at scale. Beyond addressing current challenges, quantum computing opens new frontiers for research and application, creating exciting opportunities across the AI landscape.

Bridging The Innovation Gap For The Broader AI Landscape

As we explore the potential of quantum machine learning, it is crucial to understand how it integrates with the broader AI ecosystem.

Best High-Yield Savings Accounts Of 2024

Best 5% interest savings accounts of 2024.

Interdisciplinary Synergy: Quantum machine learning epitomizes the convergence of quantum physics, computer science and artificial intelligence. This fusion creates a powerful synergy that leverages quantum algorithms, such as the Quantum Approximate Optimization Algorithm (QAOA) and Variational Quantum Eigensolver (VQE), to solve optimization and eigenvalue problems more efficiently than classical counterparts. These algorithms enable the development of more sophisticated machine learning models, enhancing tasks such as classification, clustering and regression.

Algorithmic Advancements: QML brings forward new algorithmic paradigms, including quantum neural networks (QNNs) and quantum support vector machines (QSVMs). QNNs, inspired by classical neural networks, leverage the principles of quantum mechanics to process information in fundamentally different ways, potentially offering exponential speedups for training and inference. QSVMs extend the classical support vector machines by exploiting quantum kernels, which can map data into higher-dimensional quantum feature spaces, enabling better separation of complex data patterns.

Scalability And Efficiency: With their inherent parallelism, quantum computers can address the curse of dimensionality in machine learning. Techniques such as Quantum Principal Component Analysis (QPCA) and Quantum Boltzmann Machines (QBM) can efficiently handle high-dimensional datasets, providing scalable solutions to problems that are currently intractable for classical systems.

Error Mitigation And Fault Tolerance: As we advance toward practical quantum computing, addressing errors and decoherence is crucial. Techniques like Quantum Error Correction (QEC) and fault-tolerant quantum computing are essential to ensure the reliability and stability of quantum algorithms. These advancements are pivotal in realizing the full potential of QML, enabling robust and accurate AI models.

Practical Implementations: This technology is not merely theoretical. Companies across various industries are already experimenting with quantum algorithms to improve their products and services.

Ethical Considerations: As these technologies evolve, ethical concerns regarding data privacy, security and the societal impact of AI become paramount. Ensuring transparency and regulation will be vital to harnessing these advancements for the greater good. The integration of quantum cryptography with QML can provide enhanced security measures, safeguarding sensitive data and reinforcing trust in AI systems.

Quantum machine learning stands at the forefront of AI research and application, promising to address some of the most challenging problems across various industries. By appreciating the potential of QML, we can look forward to a future where AI continues to drive innovation and enhance our daily lives. Staying informed about these advancements is essential as they increasingly influence the world around us, shaping a smarter, more efficient and secure future.

Forbes Technology Council is an invitation-only community for world-class CIOs, CTOs and technology executives. Do I qualify?

• Editorial Standards
• Reprints & Permissions

share this!

June 27, 2024

This article has been reviewed according to Science X's editorial process and policies . Editors have highlighted the following attributes while ensuring the content's credibility:

fact-checked

trusted source

Visual explanations of machine learning models to estimate charge states in quantum dots

by Tohoku University

A group of researchers has successfully demonstrated automatic charge state recognition in quantum dot devices using machine learning techniques, representing a significant step toward automating the preparation and tuning of quantum bits (qubits) for quantum information processing.

Details of the research were published in the journal APL Machine Learning on April 15, 2024.

Semiconductor qubits use semiconductor materials to create quantum bits. These materials are common in traditional electronics, making them integrable with conventional semiconductor technology. This compatibility is why scientists consider them strong candidates for future qubits in the quest to realize quantum computers.

In semiconductor spin qubits, the spin state of an electron confined in a quantum dot serves as the fundamental unit of data, or the qubit. Forming these qubit states requires tuning numerous parameters, such as gate voltage, something performed by human experts.

However, as the number of qubits grows, tuning becomes more complex due to the excessive number of parameters. When it comes to realizing large-scale computers, this becomes problematic.

"To overcome this, we developed a means of automating the estimation of charge states in double quantum dots, crucial for creating spin qubits where each quantum dot houses one electron," says Tomohiro Otsuka, an associate professor at Tohoku University's Advanced Institute for Materials Research (WPI-AIMR).

Using a charge sensor, Otsuka and his team obtained charge stability diagrams to identify optimal gate voltage combinations ensuring the presence of precisely one electron per dot. Automating this tuning process required developing an estimator capable of classifying charge states based on variations in charge transition lines within the stability diagram.

To construct this estimator, the researchers employed a convolutional neural network (CNN) trained on data prepared using a lightweight simulation model: the Constant Interaction model (CI model). Pre-processing techniques enhanced data simplicity and noise robustness, optimizing the CNN's ability to accurately classify charge states.

Upon testing the estimator with experimental data , initial results showed effective estimation of most charge states, though some states exhibited higher error rates. To address this, the researchers utilized Grad-CAM visualization to uncover decision-making patterns within the estimator.

They identified that errors were often attributed to coincidental-connected noise misinterpreted as charge transition lines. By adjusting the training data and refining the estimator's structure, researchers significantly improved accuracy for previously error-prone charge states while maintaining the high performance for others.

"Utilizing this estimator means that parameters for semiconductor spin qubits can be automatically tuned, something necessary if we are to scale up quantum computers," says Otsuka. "Additionally, by visualizing the previously black-boxed decision basis, we have demonstrated that it can serve as a guideline for improving the estimator's performance."

Provided by Tohoku University

Explore further

Feedback to editors

The Milky Way's eROSITA bubbles are large and distant

8 hours ago

Saturday Citations: Armadillos are everywhere; Neanderthals still surprising anthropologists; kids are egalitarian

NASA astronauts will stay at the space station longer for more troubleshooting of Boeing capsule

12 hours ago

The beginnings of fashion: Paleolithic eyed needles and the evolution of dress

Jun 28, 2024

Analysis of NASA InSight data suggests Mars hit by meteoroids more often than thought

New computational microscopy technique provides more direct route to crisp images

A harmless asteroid will whiz past Earth Saturday. Here's how to spot it

Tiny bright objects discovered at dawn of universe baffle scientists

New method for generating monochromatic light in storage rings

Soft, stretchy electrode simulates touch sensations using electrical signals

Relevant physicsforums posts, list of verdet constants.

Jun 26, 2024

What will be the reading of this vernier calliper?

Magnetic fields in a vacuum.

Jun 24, 2024

Gravitational analog of electromagnetic force

Jun 21, 2024

Stable solutions to simplified 2 and 3 body problems?

Jun 19, 2024

Gravity & organic matter

Jun 18, 2024

More from Other Physics Topics

Related Stories

Realizing clean qubits for quantum computers using electrons on helium

Mar 28, 2024

Understanding quantum states: New research shows importance of precise topography in solid neon qubits

The tunable coupling of two distant superconducting spin qubits

May 22, 2024

Research demonstrates high qubit control fidelity and uniformity in single-electron control

May 2, 2024

Experiment opens door for millions of qubits on one chip

May 6, 2024

Shortcut to success: Toward fast and robust quantum control through accelerating adiabatic passage

Mar 5, 2024

Recommended for you

New NOvA results add to mystery of neutrinos

LHCb investigates the rare Σ+→pμ+μ- decay

Re-analyzing LHC Run 2 data with cutting-edge analysis techniques allowed physicists to address old discrepancy

Jun 27, 2024

Experiment captures atoms in free fall to look for gravitational anomalies caused by dark energy

New calculation approach allows more accurate predictions of how atoms ionize when impacted by high-energy electrons

Researchers capture detailed picture of electron acceleration in one shot

Let us know if there is a problem with our content.

Use this form if you have come across a typo, inaccuracy or would like to send an edit request for the content on this page. For general inquiries, please use our contact form . For general feedback, use the public comments section below (please adhere to guidelines ).

Please select the most appropriate category to facilitate processing of your request

Thank you for taking time to provide your feedback to the editors.

Your feedback is important to us. However, we do not guarantee individual replies due to the high volume of messages.

E-mail the story

Your email address is used only to let the recipient know who sent the email. Neither your address nor the recipient's address will be used for any other purpose. The information you enter will appear in your e-mail message and is not retained by Phys.org in any form.

Newsletter sign up

Get weekly and/or daily updates delivered to your inbox. You can unsubscribe at any time and we'll never share your details to third parties.

More information Privacy policy

Donate and enjoy an ad-free experience

We keep our content available to everyone. Consider supporting Science X's mission by getting a premium account.

E-mail newsletter