Resource efficient quantum kernel with iterative appending for support vector machines

Abstract

A quantum logic circuit comprising: a plurality of quantum logic gates configured in a nested structure comprising layers; wherein each of the layers operates on a number of qubits to encode F features from at least one data point, wherein the number of qubits in a preceding layer is higher than the number of qubits in a subsequent layer, and wherein the F features are coherently aggregated in each subsequent layer without measurement thereby reducing the number of qubits required to encode the F features for processing.

Description

RESOURCE EFFICIENT QUANTUM KERNEL WITH ITERATIVE APPENDING FOR SUPPORT VECTOR MACHINES FIELD

[0001] Aspects of the disclosure relate to methods and systems for quantum machine learning techniques. BACKGROUND

[0002] Quantum machine learning (QML) offers transformative potential for high-dimensional data analysis, yet conventional quantum feature maps are often constrained by the linear growth of qubit requirements and concomitant quadratic growth of controlled-not gate requirements.

[0003] High-dimensional data is prevalent in modern machine learning tasks, including image and speech recognition, natural language processing, and medical diagnostics. While classical machine learning techniques can handle these high- dimensional problems, they often require substantial computational resources, particularly as the dimensionality of the data increases. Quantum computing has emerged as a promising avenue to address these challenges.

[0004] Quantum computing, harnessing the principles of quantum mechanics, presents an opportunity to perform computations that could be infeasible for classical computers. In particular, quantum machine learning (QML) aims to apply quantum algorithms to pattern recognition and machine learning tasks, offering potential speedups and efficiencies in handling complex, high-dimensional data [1].

[0005] An important component of quantum machine learning is mapping classical data into the quantum state space, a process known as feature mapping. Quantum feature maps translate classical data into a quantum form that can be manipulated using quantum circuits, enabling the application of quantum algorithms [2]. However, conventional quantum feature maps require a number of qubits that grows linearly with the dimensionality of the data. This requirement poses a significant challenge, particularly in the era of noisy intermediate-scale quantum (NISQ) devices, where the number of qubits is limited [3].

[0006] Several quantum feature maps have been proposed to address high- dimensional data, such as the ZZFeatureMap and the ZFeatureMap. Yet, these methods often require a number of qubits proportional to the feature dimensions [17,18]. This linear growth limits the applicability of quantum machine learning algorithms, particularly in the context of big data, where the feature dimension can be enormous.

[0007] As well, current quantum feature maps require numbers of controlled-not (CNOT) gates that scale quadratically with the number of features and thereby with the number of qubits. These gates represent the dominant sources of errors on current quantum devices, which again limits the applicability of quantum machine learning algorithms to applications with large feature dimensions.

[0008] Quantum Feature Maps (QFMs) play an important role in quantum machine learning, enabling the encoding of classical data into the quantum state space. The quantum state space, sometimes referred to as the quantum space, is the Hilbert space that represents any quantum state. In the case of ^^ qubits, this is a 2^^- dimensional vector space over the complex field, equipped with an inner product, that can be used to mathematically represent all possible quantum states of ^^ qubits and all possible operations thereupon. This encoding process transforms classical vectors into the amplitudes of quantum states, thus facilitating quantum processing. QFMs underlie any parametrized quantum circuit or quantum kernel model

[0019] and thus cover a large swath of QML protocols. In this section, the applications and limitations of the mathematical foundations of QFMs are explored.

[0009] A quantum feature map is defined as a function ^^: ℝ^^→ ℋ, where ℋ is the Hilbert space of a quantum system. Given a classical vector ^^ ∈ ℝ^^, the map ^^ transforms ^^ into a quantum state:

[0010] | ^^^ , (1) ^^=0

[0011] where ^^^^( ^^) are scalar functions of the classical data and | ^^^ represents a computational basis state.

[0012] Examples of quantum maps are described below:

[0013] Pauli feature map: Defined by a series of Pauli gates and parameterized rotations, this map is expressed by [4]:

[0014]

[0015] where each ^^^^is chosen to be one of the three Pauli matrices acting on the ^^th qubit and the components of the classical data ^^ are labelled by ^^^^[4]. A standard choice takes ^^^^to be the Pauli ^^ matrix acting on the ^^th qubit and the initial states of each of the ^^ qubits to be a superposition of computational basis states formed by ^^|0^, whence the feature map is known as the Pauli-Z feature map or the ZFeatureMap.

[0016] The ZZ feature map extends the Pauli-Z feature map by including interactions between qubits. This feature map applies alternating ^^-rotations and ^^ ^^- entangling gates. It has been used in various classification tasks

[0017] , where the ^^ ^^- entangling gates take the form:

[0018] where ^^^^and ^^^^are Pauli-Z matrices acting on the ^^th and ^^th qubit, respectively [17,18].

[0019] All of the mentioned quantum feature maps require the number of qubits to grow linearly with the dimensionality of the data, requiring one qubit per datum. This requirement becomes prohibitive with high-dimensional data, particularly with current NISQ devices [3]. In the case of ZZFeatureMap the circuit depth grows linearly and the number of CNOT gates in the circuit grows quadratically with number of features in the data (see Figure 1). Appendix B explains why the ZZFeatureMap is more important than the ZFeatureMap for comparisons, as the latter can seldom be used on its own when nonlinear functions of the input data are necessary. SUMMARY

[0020] In one of its aspects, a quantum logic circuit comprising: a plurality of quantum logic gates configured in a nested structure comprising layers; wherein each of the layers operates on a number of qubits to encode F features from at least one data point, wherein the number of qubits in a preceding layer is higher than the number of qubits in a subsequent layer, and wherein the F features are aggregated in each subsequent layer thereby reducing the number of qubits required to encode the F features for processing.

[0021] In another of its aspects, the quantum logic circuit, wherein the nested structure comprises an input layer, at least one intermediate layer, and an output layer.

[0022] In another of its aspects, the quantum logic circuit, wherein the plurality of quantum logic gates forms a feature map for encoding multidimensional data onto a quantum state space while reducing the number of qubits.

[0023] In another of its aspects, the quantum logic circuit, wherein a number of the plurality of quantum logic gates in the preceding layer is higher than the number of the plurality of quantum logic gates in the subsequent layer.

[0024] In another of its aspects, the quantum logic circuit, wherein the number of qubits for encoding F features is reduced to F / m in each subsequent layer, where m is an integer.

[0025] In another of its aspects, the quantum logic circuit, wherein the nested structure reserves a fractional portion of the number of qubits for an ensuing iteration while sending a remaining fractional portion of the number of qubits to a quantum machine learning application.

[0026] In another of its aspects, the quantum logic circuit, wherein the fractional portion of the number of qubits for an ensuing iteration is one half (m / 2).

[0027] In another of its aspects, the quantum logic circuit, wherein fractional portion of the number of qubits for an ensuing iteration is (m-1) / m and the remaining fractional portion of the number of qubits is 1 – ((m-1) / m), where m is an integer.

[0028] In another of its aspects, the quantum logic circuit, wherein the F features are sequentially input into the input layer and information is sequentially funnelledinto progressively fewer qubits in each of at least one intermediate layer and the output layer.

[0029] In another of its aspects, the quantum logic circuit, wherein the data is mapped non-linearly to the quantum state space.

[0030] In another of its aspects, the quantum logic circuit, wherein the feature map is a multidimensional feature map.

[0031] In another of its aspects, a computer-implemented method for encoding data onto qubits in a quantum state space, the method comprising the steps of: (i) configuring a quantum logic circuit comprising a plurality of processing stages comprising quantum logic gates in a nested structure; (ii) at one of the plurality of processing stages, partitioning the qubits into two subsets of the qubits and performing coherent encoding operations on one of the two subsets of qubits destined for output and sending another of the subset of the qubits to a subsequent processing stage; (iii) at subsequent processing state, partitioning the another of the subset of the qubits into two further subsets of the another of the subset of the qubits, and performing coherent encoding operations on one of the two further subsets of the qubits destined for output and determining whether to send the another of the two further subsets of the qubits for measurement thereby terminating the operations, or to send the another of the two further subsets of the qubits to a next subsequent processing stage and repeating operation (iii) until a determination is made to terminate the operations.

[0032] In another of its aspects, the method, wherein the quantum logic gates form a feature map for encoding multidimensional data to a quantum state space while minimizing the number of qubits.

[0033] In another of its aspects, the method, wherein each subsequent layer has fewer quantum logic gates than a preceding layer.

[0034] In another of its aspects, the method, wherein the number of qubits in each subsequent layer is halved.

[0035] In another of its aspects, the method, wherein the coherent encoding operations on the qubits comprise features onto the qubits.

[0036] In another of its aspects, the method, wherein comprising a layer of entangling gates after each processing stage, wherein the layer of entangling gates acts on the qubits on which features were encoded.

[0037] In another of its aspects, the method, wherein the layer of entangling gates maps the data non-linearly to the quantum state space and simultaneously performs the partitioning of the qubits into the subsets of the subset of the qubits.

[0038] In another of its aspects, the method, wherein the quantum state space is a Hilbert space.

[0039] In another of its aspects, there is provided an innovative quantum feature map, or quantum kernel, designed to manage high-dimensional data sets without the need for a proportional increase in qubit usage. The innovative quantum feature map optimizes the use of currently available but limited qubit resources and expands the range of data complexities that quantum machine learning algorithms can tackle effectively.

[0040] The quantum kernel is uniquely designed to handle high-dimensional data with a significantly reduced number of qubits and number of controlled-not gates. The quantum kernel approach preserves essential data characteristics while promoting computational efficiency. The quantum kernel comprises a nested structure, that is, the quantum kernel employs alternate layers of unitary operations to reduce the number of qubits required to be measured for analyzing the data, encodes more data on the now-available qubits in a coherent process, then repeats the process on the smaller number of qubits, with all of the qubits being measured once at the end. The number of qubits required to encode F features is reduced relative to established feature maps, which require F qubits, to F / m for a positive integer m, while the number of controlled-not gates is reduced from the order of F2to the order of m2F; repeating quantum kernel k times with different features, the qubit requirement diminishes to F / mk and the number of controlled-not gates remains on the order of m2F. This kernel can be used in any support vector machine and is shown to be successful at classifying high-dimensional data, even with large imbalances between classes. The noisy simulations results highlight this kernel’s ability to function within the constraints of noisy intermediate-scale quantum devices. Extensive experiments onbenchmark datasets demonstrate a marked improvement in both accuracy and resource utilization, as compared to state-of-the-art quantum feature maps that are expected to achieve quantum advantages, even compared to noise-free versions of the latter. As such, the quantum kernel enables practical implementation of QML algorithms on current and near-future quantum computing platforms, effectively overcoming a significant barrier in the field in terms of the number of features in a dataset that can be analyzed. In addition, the quantum kernel paves the way for more complex applications of QML, unlocking the potential to process extensive datasets that were previously beyond the reach of existing quantum techniques. BRIEF DESCRIPTION OF THE DRAWINGS

[0041] Several exemplary embodiments of the present disclosure will now be described, by way of examples only, with reference to the appended drawings in which:

[0042] Figures 1a-d show quantum resource comparisons between the quantum kernel model (CPKernel, black dots) and the ZZfeatureMap (standard quantum model, grey triangles)for encoding data with different numbers of features;

[0043] Figure 2a shows a section of a CPKernel’s nested structure for encoding data onto a set of qubits for classification, machine learning, or other tasks, in which this section of the nested structure leaves half of the qubits for the next iteration and sends the rest of the qubits on to the application;

[0044] Figure 2b shows a section of a CPKernel’s nested structure for encoding data onto a set of qubits for classification, machine learning, or other tasks, in which the section leaves a fraction ( ^^ − 1) / ^^ of the qubits for the next iteration and sends the rest of the qubits on to the application;

[0045] Figure 3a shows an example CPKernel with 8 qubits for encoding 15 features with each step reducing the dimension by a factor of ^^ = 2;

[0046] Figure 3b shows a diagram of an example ^^ unitary, which performs an entangling operation on a pair of qubits;

[0047] Figure 3c shows a diagram of an example ^^, which performs an entangling operation on a pair of qubits;

[0048] Figure 3d shows an of Quantum CNN with 8 qubits;

[0049] Figure 4 shows a circuit for implementing ^^( ^^, ^^, ^^); Figure 5 shows a MCC-score-based analysis of different kernels on different datasets scaled to each have 7 features.

[0050] Figure 6 shows a MCC-score-based analysis for the Noisy simulation of CPKernel on different datasets, versus the noise-free performance of the CPKernel and ZZFeatureMap for those datasets;

[0051] Figure 7 shows a MCC-score-based analysis of different kernels on different datasets, each scaled to have 22 features; and

[0052] Figure 8 shows a MCC-score-based analysis of different kernels on different full datasets, without PCA, having 21, 22, and 30 features.

[0053] DETAILED DESCRIPTION

[0054] The following detailed description refers to the accompanying drawings. Wherever possible, the same reference numbers are used in the drawings and the following description to refer to the same or similar elements. While embodiments of the disclosure may be described, modifications, adaptations, and other implementations are possible. For example, substitutions, additions, or modifications may be made to the elements illustrated in the drawings, and the methods described herein may be modified by substituting, reordering, or adding stages to the disclosed methods. Accordingly, the following detailed description does not limit the disclosure. Instead, the proper scope of the disclosure is defined by the appended claims.

[0055] Moreover, it should be appreciated that the particular implementations shown and described herein are illustrative of the invention and are not intended to otherwise limit the scope of the present invention in any way. Indeed, for the sake of brevity, certain sub-components of the individual operating components, conventional data networking, application development and other functional aspects of the systems may not be described in detail herein. Furthermore, the connecting lines shown in the various figures contained herein are intended to represent exemplary functional relationships and / or physical couplings between the various elements. It should be noted that many alternative or additional functional relationships or physical connections may be present in a practical system.

[0056] The quantum kernel (or “the CPKernel”) can be used for several tasks that require data to be encoded onto quantum states. As can be seen in Figures 2a and 3a, the CPKernel has a number of layers that first find crucial features in data and then aggregate several features into a smaller number (often one) in order to reduce the total number of features. Since it is quantum, all of the operations are performed on qubits using unitary gates and serve to focus the features of the data onto a reduced number of qubits, such that the resources made available by the aggregation can be used for further processing.

[0057] The CPKernel begins with encoding layers that encode data onto qubits to be processed; continues with coherent operations that perform gates on subsets of qubits; follows with partitioning unitary operations that split the qubits into different types for output or further processing, without measurement; and finishes with encoding layers that encode new data and start the process again on the qubits not yet sent to output. This nested structure with repeated opportunities for data to be encoded onto the same qubits thereby allows higher-dimensional data sets to be encoded onto fewer qubits. These create a feature map that efficiently encodes data onto a set of qubits through iterative appending.

[0058] Figure 2a, 2b shows a section of a CPKernel’s nested structure for encoding data onto a set of qubits for classification, machine learning, or other tasks, in which this section of the nested structure leaves half of the qubits for the next iteration and sends the rest of the qubits on to the application. Figure 2a or 2b shows a section of a CPKernel’s nested structure for encoding data onto a set of qubits for classification, machine learning, or other tasks, in which the section leaves a fraction ( ^^ − 1) / ^^ of the qubits for the next iteration and sends the rest of the qubits on to the application. Qubits are given by lines and the operations that act on them are depicted from left to right. The partially shaded circles E encode a single data feature onto a single qubit using single-qubit operations. The dark rounded boxes C each perform a coherent circuit that unitarily transforms blocks of 2 qubits in Figure 2a and a generic number of qubits ^^ in Figure 2b. Each qubit experiences two C boxes in each layer such that the resultant entangled state can have contributions from all qubits. The unshaded boxes P perform a partitioning circuit that unitarilytransforms blocks of 2 qubits in Figure 2a such that 1 qubit is output for application and 1 qubit is sent to the next level of the nested structure to have more data encoded and processed; and that unitarily transforms blocks of generic number of qubits ^^ in Figure 2b such that 1 qubit is output for application and ^^ − 1 qubits are sent to the next level of the nested structure to have more data encoded and processed. The fractions that are sent for application versus to the next level of the nested structure can be chosen at will. For the nested structure, the output qubits from all of the previous partitioning layers that are not sent for application have new data encoded via E and are aggregated to enter the next ^^ and ^^ layers. When there are not enough qubits left to perform more full ^^ and ^^ operations, the qubits can all be sent to the application, which may involve trainable circuits and / or measurement of the qubits.

[0059] Generally, referring to Figure 3d, quantum convolutional neural networks (QCNNs) are a quantum analog of classical convolutional neural networks (CNNs), designed to process quantum data and perform quantum computations. In a QCNN, the convolutional layer applies a series of quantum gates ( ^^1and ^^2) to small, localized regions of the input quantum data, which are parameterized by a set of learnable parameters. Generally, a quantum gate or quantum logic gate is the basic logic unit to operate on one or more quantum bits (qubits), and a quantum logic circuit is a series of quantum gates acting sequentially or in parallel on one or more qubits. A quantum logic circuit may refer to both the logical configuration of operations and the physical embodiment of such operations on any physical manifestation of qubits. These quantum gates can be thought of as the quantum equivalent of the convolutional filters in classical CNNs, they are designed to detect various features or patterns in the input data, such as edges or textures in an image. The parameters of these quantum gates are updated during the training process using quantum versions of classical optimization techniques, such as gradient descent. This allows the QCNN to learn to detect features that are relevant for a particular task, such as classifying images or detecting anomalies in a dataset [5,20].

[0060] The pooling layers in a QCNN are responsible for reducing the dimensionality of the quantum data, thereby reducing the computational cost of subsequent layers and helping to network invariant to small translations inthe input. In a quantum pooling layer, a subset of the qubits is measured, and the outcomes of these measurements are used to decide which qubits to keep and which to discard. This is analogous to the way classical pooling layers (e.g., max-pooling layers) retain only the most important information from the input, discarding the rest to produce a condensed representation. The pooling operation in QCNNs is non-trivial due to the inherent nature of quantum measurements, which are probabilistic and cause the quantum state to collapse. Designing effective quantum pooling operations that preserve relevant information while reducing dimensionality is an active area of research [5,6]. An example of a QCNN with 8 qubits is featured in Figure 3d, where the measurement and feedforward operations are seen to halve the number of remaining qubits at each step.

[0061] Figure 3a shows an example CPKernel with 8 qubits encoding 15 features with each step reducing the dimension by a factor of ^^ = 2. ^^ is a Hadamard gate that makes superpositions out of states in the computational basis, ^^^^( ^^) performs a Pauli rotation around the ^^ axis by angle ^^ to encode the data, ^^ is a unitary matrix acting coherently on a pair of qubits, ^^ is a partitioning unitary matrix acting on a pair of qubits, and all qubits are then output to be used in any application (including measurement, repetition of the kernel, input to a quantum neural network, etc.). Figure 3b shows a diagram of an example ^^ unitary, which performs an entangling operation on a pair of qubits. Figure 3c shows a diagram of an example ^^, which performs an entangling operation on a pair of qubits. Figure 3d shows an illustration of a QCNN with 8 qubits. The two-qubit unitaries ^^1and ^^2perform convolutions, then the pooling operations are done by measurements ℳ on one qubit followed by feedforward unitaries ^^1and ^^2on the other qubit; all such operations typically involve parameters that must be trained. The pooling operations of Figure 3d are replaced by ^^ in Figures 3a and 3c and more data features are encoded in Figure 3a before the subsequent step of the network.

[0062] The CPKernel uses an idea reminiscent of the QCNN to encode more features in a limited space. Instead of discarding the qubits after the pooling layer, the CPKernel uses those leftover qubits for processing more features; pooling is thus replaced by partitioning. However, it is a kernel, optimization on the parametersis not performed, and measurement happens only at the end, if at all; the new data are uploaded in a coherent process and all of the encoded data can be processed in a multitude of ways prior to measurement. Therefore, while the CPKernel looks structurally similar to a QCNN, the CPKernel works in a different manner. The CPKernel uses two circuits similar to the convolutional and pooling circuits of QCNN to partition down the information from ^^ qubits to ^^ < ^^ qubits per block.

[0063] A generic diagram of a CPKernel is shown in Figures 2a and 2b, and an example detailed diagram of CPKernel and QCNN can be found in Figures 3a and 3d. That example is based on the QCNN from Ref. [5], where the convolutional and ^^ pooling layers each focus the data from a set of ^^=2 qubits onto ^^ = 2 = 1 qubits and the figure depicts an 8-qubit network. Individual features are encoded in the standard way by the application of a Hadamard gate and a Pauli rotation proportional to the datum and any similar encoding can be used. The measurement and feedforward part of the circuit in Figure 3d is replaced with a partitioning unitary ^^ in Figures 3a and 3c. If the structure for the CPKernel, as shown in Figure 3a, is used, then the total ^^ number of features that can be encoded into ^^ total qubits is approximately ^^ + 2 + ^^ 22+ ⋯ = 2 ^^. Partitioning the unitaries that each focus the data from ^^ qubits onto ^^ = ^^ − 1, as in Figure 2b results in the total number of features that can be encoded to be approximately ^^ ^^. Then, because the entire process is coherent with no intermediate measurements, any or all of the steps can be repeated with the same or new data prior to measurement, allowing the number of encoded features to increase by a multiplicative factor that can be as large as the number of repetitions ^^. These allow a limited number of qubits to be used efficiently for processing data with significantly larger numbers of features.

[0064] With this general structure in mind, one can specify different choices of the coherent unitaries ^^ and partitioning unitaries ^^, which are each chosen to act on pairs of qubits in Figures 2a and 3a-c but can act on any number of ^^ qubits when partitioning by a factor of ^^, as schematized in Figure 2b. One can then assess whether a given choice succeeds for a given machine learning task and also assess the total complexity of the circuit to implement these unitaries. Recall thatencoding a data point with ^^ features using the ZZFeatureMap requires on the order of ^^ qubits and ^^2CNOT (entangling) gates in order to allow for arbitrary operations on the data. For the CPKernel, each ^^ and ^^ unitary requires on the order of ^^2CNOT gates to analyze and focus the data from ^^ qubits onto ^^ − 1 qubits in general. The total number of ^^ and ^^ unitaries is proportional to the total number of data features, ^^−1 which can be seen because each subsequent step requires ^^ times as many ^^ and ^^ unitaries as the previous step and each step requires twice as many ^^ unitaries as ^^ unitaries. In sum, with a total of ^^ qubits, the CPKernel encodes up to ^^ ^^ features using on the order of ^^3^^ CNOT gates. In terms of the number of features, the CPKernel thus only requires ^^ / ^^ qubits, which is better than the ZZFeatureMap by a factor of ^^, and only requires on the order of ^^2^^ CNOT gates, which can be much smaller than the ^^2gates required by the ZZFeatureMap when the number of features is large. If the circuit is repeated ^^ times prior to measurement with ^^ times as many data features, the CPKernel is able to process ^^ features using ^^ / ( ^^ ^^) qubits using ( ^^3^^) ^^ = ^^2^^ CNOT gates; larger choices of ^^ allow for more features to be encoded using the same number of qubits and the same number of CNOT gates.

[0065] Since partitioning by too large of a factor can fail to capture some crucial features of the data, a CPKernel with ^^ = 2 is chosen in the examples and comparisons, as shown in Figures 3a-c. Depending on the dataset at hand, different partitioning factors and different choices of ^^ and ^^ unitaries will be optimal, the choice of which can be considered as hyperparameters of the CPKernel.

[0066] Next, a structure for the ^^ and ^^ unitaries acting on pairs of qubits is specified; these will be the same when applied to any pair of qubits, but can be chosen to be different for different parts of the circuit if one wishes to treat these as further hyperparameters of the CPKernel. The ^^ and ^^ unitaries are inspired from the fact that any matrix in U(4), which is the most general group of matrices acting on a pair of qubits, may be written in the form [7,8]:

[0067] ^^ =(^^1⊗ ^^2)^^(^^, ^^, ^^)(^^3⊗ ^^4), (4)

[0068] where each matrix ^^^^∈SU(2) acts on a single qubit and ^^(^^, ^^, ^^)= exp [ ^^(^^ ^^1^^2+ ^^ ^^1^^2+ ^^ ^^1^^2)] is gate acting on the two qubits. Thatis, any information encoded into 2-qubits can be represented using equation (4) with the help of 15 parameters.

[0069] The parameters of ^^ used in the the ^^ and ^^ unitaries can be considered hyperparameters of the quantum kernel. Any choice of them is permitted and different choices will be optimal for different data sets. In the examples, the simplest SU(2) unitary, the identity matrix, is considered for each ^^^^and is sufficient for showcasing the results and reduces the equation (4) to

[0070] ^^ = ^^(^^, ^^, ^^), (5)

[0071] and the number of hyperparameters to 3. The circuit for implementing ^^(^^, ^^, ^^)is shown in Figure 4 [7]. In the examples described herein, the six parameters in the ^^ and ^^ unitaries are arbitrarily chosen, and resulted in favorable outcomes, which showcases the tolerance of this quantum kernel to choices of its hyperparameters. The circuits for the ^^ and ^^ unitaries with these chosen parameters are shown in Figure 3b and 3c, respectively; alternate choices for these unitaries will also offer the same advantages in scaling with quantum resources. With these specific choices, it can be seen that the resources to scale much more favourably for the CPKernel than the ZZFeatureMap, as shown in Figure 1a-d.

[0072] The ZZ feature map is commonly used in quantum machine learning tasks, while the CPKernel is inspired by convolutional neural networks to use fewer qubits per number of data features. The representational capacity is a proxy for the complexity of the functions of the input data that the map can distinguish between, which is high for the two maps due to their entangling features that explore more sections of Hilbert space than non-entangling maps (such as the ZFeatureMap).

[0073] Results

[0074] The performance of the CPKernel was benchmarked against several established quantum and classical kernels to ascertain its capabilities. Several datasets characterized in Table 1 were used to check its performance as a support vector classifier for classifying data into discrete categories.

[0075] Table 1: Properties of Various Datasets used in this studyDataset Number of Number of Classes Features Samples Ionosphere 34 351 2 Breast cancer diagnostic 30 569 2 (Wisconsin) Credit card fraud detection 30 984 2 (balanced) Parkinson’s disease (PD) 22 195 2 Stellar classification dataset – 17 100000 3 SDSS17 Heart disease 11 918 2 Titanic 10 891 2 Agaricus Lepiota Mushroom 21 8145 2

[0076] Owing to the skewed nature of the majority of the test data, with strong imbalances between the numbers of samples in each class, the Matthews Correlation Coefficient (MCC) was selected as the primary evaluation criterion (as described in Appendix A). The MCC serves as a reliable metric, offering a comprehensive assessment of binary classification outcomes by considering both true and false positives as well as negatives. A score of +1 in MCC denotes impeccable prediction accuracy, 0 suggests no better than a random prediction, and -1 signifies a complete mismatch between the predicted and actual outcomes. The MCC is defined as

[0077] TP ⋅ TN − FP ⋅ FN MCC = , (6) √(TP + FP)(TP + FN)(TN + FP)(TN + FN)

[0078] where TP is the number of true positives, TN is the number of true negatives, FP is the number of false positives and FN is the number of false negatives.

[0079] In one study, the Qiskit's Statevector simulator, a tool designed to simulate the ideal quantum states of a quantum system without any external noise or decoherence, was used. This simulator provides a precise representation of the quantum state, allowing for accurate computations and predictions. It is particularly beneficial for theoretical and understanding the ideal behaviour ofquantum algorithms. Alongside the Statevector simulator, Qiskit's noisy simulators were also used. These noisy simulators are designed to mimic real IBM quantum devices by leveraging system snapshots. Such snapshots capture vital data about the quantum setup, including the coupling map, foundational gates, and qubit attributes (T1, T2, error rates, and more), proving instrumental for transpiler testing and conducting system simulations with noise. These noisy simulators present a more grounded view of quantum operations in tangible settings. Their use enabled the assessment of the durability of the algorithms in authentic environments and helped refine them to better withstand quantum disruptions and other unforeseen challenges.

[0080] Results with Seven Features After PCA

[0081] In the initial phase of the study, Principal Component Analysis (PCA) was employed to reduce the feature set to seven across all datasets. Specifically, the sample size of the Stellar Classification Dataset was limited to 2,000 and excluded the QSO class to expedite the simulation process.

[0082] The capabilities of both the SciKit Learn [9] and QisKit

[0010] libraries were leveraged for Support Vector Classification (SVC).

[0083] Figure 5 shows a MCC-score-based analysis of different kernels on different datasets scaled to each have 7 features. The CPKernel (second from right for each dataset) always outperforms the ZZFeatureMap quantum kernel (rightmost for each dataset) and always performs better than one or more of the classical kernels across a diverse range of datasets. The CPKernel is almost always on par with the best classical kernel for each dataset and sometimes outperforms all of the classical kernels (linear, poly, rbf, sigmoid), highlighting its promising applications in the realm of quantum machine learning. For some datasets, certain kernels completely failed, so there is no bar visible for the ZZFeatureMap for the Ionosphere and Parkinson’s datasets and for the sigmoid for the Breast Cancer dataset; note that the centres of each set of six bars is labeled by a tick. As such, it is evident from Figure 5 that the CPKernel stands out, often by a considerable margin, highlighting its robustness and efficiency in classification tasks.

[0084] For some data sets, the CPKernel was repeated up to two times but uploaded the same features for each (see Table 2). This increases the totalnumber of CNOT gates by a factor of two but maintains the total number of qubits and the significant reduction in the number of CNOT gates. Results for different data sets scaled to each have 7 features (except the Titanic data set denoted by * for which no PCA was done; three features were simply ignored). The number of repetitions (NOR) for the CPKernel was either two (Max.) or one each data set, maintaining significantly qubits and fewer CNOT gates than the ZZFeatureMap that was repeated once for each dataset. The CPKernel always outperformed the ZZFeatureMap even with one repetition, while the second repetition improved its MCC score even more.

[0085] Table 2: Results for different data sets scaled to each have 7 features Dataset NOF Max. NOR for MCC MCC MCC Score used NOR for ZZFeatureMap Score Score ZZFeatureMap CPKernel CPKernel (1 (Max.) rep.) Ionosphere 7 1 1 0.643 0.643 0.0 Breast 7 2 1 0.944 0.926 0.869 cancer diagnostic (Wisconsin) Credit card 7 1 1 0.831 0.831 0.602 fraud detection (balanced) Parkinson’s 7 2 1 0.520 0.451 0.0 disease (PD) Stellar 7 2 1 0.791 0.778 0.300 classification dataset – SDSS17 Heart disease 7 2 1 0.664 0.621 0.449 Titanic 7* 1 1 0.561 0.561 0.351

[0086] Other Results

[0087] Results for the Noisy Simulation with Seven Features

[0088] In addition to standard simulations, noisy simulations were conducted on four specific datasets: Stellar Classification, Balanced Credit Card, Heart Disease, and Ionosphere. Due to computational constraints and extended runtimes, the number of features was restricted to seven in the Heart Disease, Balanced Credit Card, and Ionosphere datasets post-PCA. These noisy simulations were executed using Qiskit's specialized noisy simulators, which emulate real quantum devices. Specifically, the fake_ibqm_manila backend for the Balanced Credit Card and Heart Disease datasets, the fake_ibmq_jakarta backend for Stellar Classification, and fake_ibm_perth for Ionosphere, were employed. The outcomes of these simulations are illustrated in Figure 6. In more detail, Figure 6 shows the MCC score for the noisy simulation of CPKernel on different datasets, versus the noise-free performance of the ZZFeatureMap for those datasets. The leftmost bar for each cluster is the original noise-free result of the CPKernel, the middle bar is the result for the noisy CPKernel, and the rightmost bar is the original noise-free result of the ZZFeatureMap.

[0089] As can be seen in Figure 6, the CPKernel consistently surpassed the performance of ZZFeatureMap, even in the presence of noise. On some data sets, the CPKernel was repeated up to two times but the same features were uploaded for each repetition (see Table 2). This increases the total number of CNOT gates by a factor of two but maintains the total number of qubits and the significant reduction in the number of CNOT gates. The advantages in the noisy simulations demonstrate that the extra repetitions of the CPKernel are still much more tractable than even an idealized ZZFeatureMap.

[0090] Results too big for ZZFeatureMap

[0091] Next considered are datasets with so many features that it is prohibitive to simulate the ZZFeatureMap on a classical computer due to the exorbitant qubit- and gate-count requirements. For some data sets, the CPKernel was repeated up to six times but the same features were uploaded for each repetition (see Table 4). This increases the total number of CNOT by a factor of six but maintains the totalnumber of qubits and the significant reduction in the number of CNOT gates such that they are still more tractable than the ZZFeatureMap. Table 4 also displays how the results were almost ideal after a single repetition, with extra repetitions slightly improving the final MCC scores.

[0092] Table 4: Results for different data sets that were too large to be analyzed using the ZZFeatureMap. Dataset NOF Max. NOR for MCC Score MCC used CPKernel CPKernel (Max.) Score (1 rep.) Ionosphere 22 2 0.866 0.832 Breast cancer 30* 2 0.943 0.908 diagnostic (Wisconsin) Credit card fraud 22 5 0.950 0.942 detection (balanced) Parkinson’s disease 22* 1 0.672 0.672 (PD) Stellar classification 16 3 0.956 0.946 dataset – SDSS17 Agaricus Lepiota 21* 6 0.996 0.910 Mushroom

[0093] Some data sets were scaled to reduce their total number of features using PCA, while denoted with the symbol * were data sets without PCA. The number of repetitions (NOR) for the CPKernel was up to six for each data set, maintaining significantly qubits and fewer CNOT gates than the ZZFeatureMap and allowing the former to be tractable while the latter was not. The exact MCC scores for a single repetition and the maximum number of repetitions are shown to display the effects of increasing repetitions on the overall performance; a single repetition is enough, while extra repetitions improve the results.

[0094] Datasets with 22 Features After PCA

[0095] PCA was performed on the Ionosphere and Credit Card Fraud datasets to reduce them to 22 features in order to them with the exact same CPKernel asfor the Parkinson’s dataset in section 4.3.2, which has exactly 22 features. The CPKernel achieves an MCC score better than all or all but one of the classical kernels for each of the datasets, as depicted in Figure 7. The CPKernel (far right for each dataset) always performs at the level of or better than the classical kernels. The ZZFeatureMap does not feature in this comparison because there are too many features for a simulation to be tractable in a reasonable amount of time.

[0096] Datasets with 22 or more Features without PCA

[0097] Finally, the CPKernel is applied to full datasets with all 21 features (Agaricus Lepiota Mushroom), 22 features (Parkinson’s) and all 30 features (Breast Cancer) with no PCA. The CPKernel achieves an MCC score better than all of the classical kernels for each of the datasets, as depicted in Figure 8. The CPKernel (far right for each dataset) always performs better than or at the level of the classical kernels. The ZZFeatureMap does not feature in this comparison because there are too many features for a simulation to be tractable in a reasonable amount of time.

[0098] Appendix A: On the Suitability of Regular Machine Learning Metrics

[0099] In the realm of machine learning, the evaluation of model performance is important. Common metrics such as accuracy, precision, recall, and F1 score are frequently employed to gauge the efficacy of models. However, these metrics, while widely accepted, are not universally applicable across all scenarios.

[0100] Imbalanced datasets, where one class significantly outnumbers the other, present a unique challenge for machine learning models and the evaluation metrics used to assess their performance. This is particularly true for binary classification tasks, where the minority class is often of greater interest than the majority class.

[0101] Limitations of Conventional Metrics

[0102] Traditional performance metrics, such as accuracy, can be misleading in the context of imbalanced datasets

[0011] . Consider a dataset with 95% samples of class A and only 5% samples of class B. A naive classifier predicting all samples as class A will still achieve a superficially high accuracy of 95%. This demonstrates that accuracy alone is not sufficient to evaluate model performance on imbalanced datasets [12,13].

[0103] Similarly, other metrics such as recall, precision, and the F1 score can sometimes provide a skewed perspective when classes are imbalanced. There are situations where models can achieve high values for these metrics by being biased towards the majority class, rendering them less effective as measures of model performance [14,15].

[0104] Matthews Correlation Coefficient (MCC)

[0105] To address the limitations of conventional metrics on imbalanced datasets, the Matthews Correlation Coefficient (MCC) can be employed. MCC is a balanced metric that takes into account both over-predictions and under-predictions across classes. Defined as: TP⋅TN−FP⋅FN

[0106] MCC = √(TP+FP)(TP+FN)(TN+FP)(TN+FN), (6)

[0107] where TP, TN, FP, and FN are the numbers of true positives, true negatives, false positives, and false negatives, respectively. The MCC returns a value in [-1, 1], with 1 representing perfect prediction, -1 indicating total disagreement between prediction and observation, and 0 suggesting no better than random prediction.

[0108] MCC is particularly valuable for imbalanced datasets as it considers all four components of the confusion matrix and is less susceptible to the bias of a large class

[0016] .

[0109] Generally, when assessing machine learning models on datasets with imbalances, exclusive dependence on conventional metrics can result in skewed insights. The Matthews Correlation Coefficient presents a more encompassing and impartial assessment criterion, aptly fitting for tasks with class disparities. It is pivotal to select a performance measure that resonates with the distinct demands and traits of the problem at hand. Particularly in quantum machine learning, given the distinct nature of data and the nuances of the models, a mere reliance on established metrics may fall short in truly capturing the model's efficacy.

[0110] Appendix B: ZFeatureMap vs. ZZFeatureMap

[0111] The `ZFeatureMap` is a simpler feature map that involves rotations around the ^^-axis of the Bloch the other hand, the `ZZFeatureMap` is atwo-qubit gate that involves rotations around both the ^^ and ^^ axes. This makes the `ZZFeatureMap` more expressive and capable of capturing more complex relationships in the data.

[0112] The primary reason for preferring `ZZFeatureMap` over `ZFeatureMap` in quantum machine learning is its ability to generate entanglement between qubits. Entanglement is a uniquely quantum phenomenon and is believed to be one of the reasons quantum algorithms can outperform classical ones [8,17]. By using `ZZFeatureMap`, quantum machine learning algorithms can leverage this entanglement to potentially achieve better performance.

[0113] While both `ZFeatureMap` and `ZZFeatureMap` have their applications, the latter is generally preferred in quantum machine learning due to its ability to capture more complex data relationships and leverage quantum entanglement.

[0114] Appendix C: Source code for CPKernel

[0115] Portions of the disclosure of this patent document, including Appendix C, contain material which is subject to copyright protection. The copyright owner(s) has no objection to the facsimile reproduction by anyone of the patent document or the patent disclosure, as it appears in the Patent and Trademark Office patent file or records, but otherwise reserves all copyright rights whatsoever.

[0116] # --- # jupyter: # jupytext: # formats: py:light # text_representation: # extension: .py # format_name: light # format_version: '1.5' # jupytext_version: 1.14.5 # kernelspec: # display_name: Python 3# language: python # name: python3 # --- # + """" Version: 0.0.1 Authors: Utkarsh Singh, Aaron Goldberg, Khabat Heshami (C) Copyright 2023. Any modifications or derivative works of this code must retain this copyright notice, and modified files need to carry a notice indicating that they have been altered from the originals. """" from qiskit import QuantumCircuit, QuantumRegister from qiskit.circuit import Parameter, ParameterVector from utility import MetaFibonacci, mapping, CPaction import numpy as np class CPKernel: def __init__(self, num_features, reps=1, insert_barriers = False, CP_params= None, CP_last_layer = False): # alpha = -np.pi / 3, beta = np.pi / 6, gamma = -np.pi / 9, param1 = np.pi / 7, param2=np.pi / 9, param3=-np.pi / 7): """ Args: num_features (int): A parameter representing number of features in the dataset. reps (int): The number of repeated circuits, has a min. value of 1. insert_barriers (Bool): If True, barriers are inserted after each mapping layers. CP_last_layer (Bool): If true, CP layers will be applied on the last layer CP_params (list, optional): A list of parameters for CMap and PMap circuit, or the Hyperparameters of the CPKernel. Defaults to a specific list of values if not provided. [alpha, beta, param1, param2, param3]""" self.num_features = num_features self.reps = reps self.insert_barriers = insert_barriers self.CP_last_layer = CP_last_layer # default parameters if none are provided if CP_params is None: CP_params = [ -np.pi / 3, np.pi / 6, -np.pi / 9, np.pi / 7, np.pi / 9, -np.pi / 7 ] self.alpha = CP_params[0] self.beta = CP_params[1] self.gamma = CP_params[2] self.param1 = CP_params[3] self.param2 = CP_params[4] self.param3 = CP_params[5] """ mapping_list (list): A list to provide number of features in each mapping layer qubits (int): Number of qubits in the circuit params (Parameter vector): List of parameters to go in the feature map circuit """self.mapping_list = mapping(self.num_features).mapping_list() self.qubits = self.mapping_list[0] self.params = ParameterVector('X', self.num_features) def cmap(self): """ A 2-qubit quantum circuit inspired from the convolutional layer of QCNN """ q1=QuantumRegister(1, 'q1') q2=QuantumRegister(1, 'q2') target = QuantumCircuit(q1,q2, name = 'C-Map') target.rz(-np.pi / 2, q2) target.cx(q2, q1) target.rz(self.alpha, q1) target.ry(self.beta, q2) target.cx(q1, q2) target.ry(self.gamma, q2) target.cx(q2, q1) target.rz(np.pi / 2, q1) return target def pmap(self): """ A 2-qubit quantum circuit inspired from the pooling layer of QCNN """ q1 = QuantumRegister(1, 'q1') q2 = QuantumRegister(1, 'q2') target = QuantumCircuit(q1, q2, name = 'P-Map') target.rz(-np.pi / 2, q2) target.cx(q2, q1) target.rz(self.param1, q1) target.ry(self.param2, q2)target.cx(q1, q2) target.ry(self.param3, q2) return target def CPMap(self): if self.num_features < 2: """ ValueError: If the feature dimension is smaller than 2. """ raise ValueError( "The CPMap contains 2-local interactions and cannot be " f"defined for less than 2 qubits. You provided {self.num_features}." ) if self.num_features == 2: print('For 2-dimensional data, CPKernel gets converted to ZFeatureMap') pass mapping_list_ = self.mapping_list last_rep = mapping_list_[-1] qc = QuantumCircuit(self.qubits, name = 'CPKernel') for rep in range(self.reps): shift = 0 for k in range(len(mapping_list_)): for i in range(mapping_list_[k]): qc.h(i) qc.p(self.params[i+shift], i) if mapping_list_[k] > last_rep: c_list = CPaction(mapping_list_[k]).cmap_list() for j in range(len(c_list)): qc.append(self.cmap(), c_list[j]) # if self.barrier is# qc.barrier() p_list = CPaction(mapping_list_[k]).pmap_list() for l in range(len(p_list)): qc.append(self.pmap(), p_list[l]) # if self.barrier is True: # qc.barrier() elif mapping_list_[k] == last_rep and last_rep>1 and self.CP_last_layer is True: c_list = CPaction(mapping_list_[k]).cmap_list() for j in range(len(c_list)): qc.append(self.cmap(), c_list[j]) # if self.barrier is True: # qc.barrier() p_list = CPaction(mapping_list_[k]).pmap_list() for l in range(len(p_list)): qc.append(self.pmap(), p_list[l]) # if self.barrier is True: # qc.barrier() else: break shift = shift + self.mapping_list[k] if self.insert_barriers is True: qc.barrier() else: pass return qc

[0117] While this specification contains many specific implementation details, these should not be construed as limitations on the scope of any invention or on the scope of what may be claimed, but rather as descriptions of features that may be specific to particular implementations of particular inventions. Certain features that are described in this specification in context of separate implementations can alsobe implemented in combination in a single implementation. Conversely, various features that are described in the context of a single implementation can also be implemented in multiple implementations separately or in any suitable sub- combination. Moreover, although features may be described above as acting in certain combinations and even initially claimed as such, one or more features from a claimed combination can in some cases be excised from the combination, and the claimed combination may be directed to a sub-combination or variation of a sub-combination.

[0118] Accordingly, the above description of example implementations does not define or constrain this disclosure. Other changes, substitutions, and alterations are also possible without departing from the spirit and scope of this disclosure.

[0119] REFERENCES [1] Jacob Biamonte et al. “Quantum machine learning”. In: Nature 549 (Sept.2017), pp.195–202.ISSN: 1476-4687. DOI: 10.1038 / nature23474. [2] Maria Schuld, Ilya Sinayskiy, and Francesco Petruccione. “An introduction to quantum machine learning”. In: Contemp. Phys. 56.2 (Apr. 2015), pp. 172–185. ISSN: 0010-7514. DOI: 10.1080 / 00107514.2014.964942. [3] John Preskill. “Quantum Computing in the NISQ era and beyond”. In: Quantum 2 (Aug.2018), p.79. DOI: 10.22331 / q - 2018 - 08 - 06 - 79.eprint: 1801.00862v3. [4] Maria Schuld and Nathan Killoran. “Quantum Machine Learning in Feature Hilbert Spaces”. In: Phys. Rev. Lett.122.4 (Feb.2019), p.040504. ISSN: 1079-7114. DOI: 10.1103 / PhysRevLett.122.040504. [5] Iris Cong, Soonwon Choi, and Mikhail D. Lukin. “Quantum convolutional neural networks”. In: Nat. Phys.15.12 (Dec.2019), pp.1273–1278. ISSN: 1745-2481. DOI: 10.1038 / s41567-019-0648-8. [6] Christa Zoufal, Aurélien Lucchi, and Stefan Woerner. “Quantum Generative Adversarial Networks for learning and loading random distributions”. In: npj Quantum Inf.5.103 (Nov.2019), pp.1–9. ISSN: 2056-6387. DOI: 10.1038 / s41534- 019-0223-2. [7] Farrokh Vatan and Colin Williams. “Optimal quantum circuits for general two- qubit gates”. In: Phys. Rev. A 69.3 (Mar.2004), p.032315. ISSN: 2469-9934. DOI: 10.1103 / PhysRevA .69.032315.[8] Abraham Asfaw et al. Learn Quantum Computation Using Qiskit. 2020. URL: https: / / qiskit.org / textbook / preface.html. [9] F. Pedregosa et al. “Scikit-learn: Machine Learning in Python”. In: Journal of Machine Learning Research 12 (2011), pp.2825–2830.

[0010] Qiskit contributors. Qiskit: An Open-source Framework for Quantum Computing.2023. DOI:10.5281 / zenodo.2573505.

[0011] Tom Fawcett. “An introduction to ROC analysis”. In: Pattern Recognit. Lett.27.8 (June 2006), pp.861–874. ISSN: 0167-8655. DOI: 10.1016 / j.patrec.2005.10.010.

[0012] Davide Chicco and Giuseppe Jurman. “The advantages of the Matthews correlation coefficient (MCC) over F1 score and accuracy in binary classification evaluation”. In: BMC Genomics 21.1 (Dec.2020), pp.1–13. ISSN: 1471-2164. DOI: 10.1186 / s12864-019-6413-7.

[0013] Nathalie Japkowicz and Shaju Stephen. “The class imbalance problem: A systematic study”. In: Intell. Data Anal. 6.5 (Jan. 2002), pp. 429–449. ISSN: 1088- 467X. DOI: 10.3233 / IDA -2002-6504.

[0014] László A. Jeni, Jeffrey F. Cohn, and Fernando De La Torre. “Facing Imbalanced Data Recommendations for the Use of Performance Metrics”. In: 2013 Humaine Association Conference on Affective Computing and Intelligent Interaction. IEEE, Sept.2013, pp.245–251. ISBN: 978-0-7695-5048-0. DOI: 10.1109 / ACII .2013.47.

[0015] Marina Sokolova and Guy Lapalme. “A systematic analysis of performance measures for classification tasks”. In: Information Processing & Management 45.4 (July 2009), pp.427–437. ISSN: 0306-4573. DOI: 10.1016 / j.ipm.2009.03.002.

[0016] Davide Chicco. “Ten quick tips for machine learning in computational biology”. In: BioData Mining 10.1 (Dec. 2017), pp. 1–17. ISSN: 1756-0381. DOI: 10.1186 / s13040-017-0155-3.

[0017] Vojtěch Havlíček et al. “Supervised learning with quantum-enhanced feature spaces”. In: Nature 567.7747 (Mar. 2019), pp. 209–212. ISSN: 1476-4687. DOI: 10.1038 / s41586-019-0980-2

[0018] US20190378025A1. Inventors: Antonio Corcoles-Gonzalez, Paul Kristan Temme, Jay M. Gambetta. Current Assignee: International Business Machines Corp. 2018 US 2019 WO

[0019] WO2022086918A1. Inventors: Jarrod Ryan MCCLEAN Hsin-Yuan Huang. 2021 WO CN US CA KR AU EP.

[0020] US20210383189A1. Iris Cong Soonwon CHOI Mikhail D. Lukin. 2019 EP WO US CA.

Claims

CLAIMS:

1. A quantum logic circuit comprising: a plurality of quantum logic gates configured in a nested structure comprising layers; wherein each of the layers operates on a number of qubits to encode F features from at least one data point, wherein the number of qubits in a preceding layer is higher than the number of qubits in a subsequent layer, and wherein the F features are aggregated in each subsequent layer thereby reducing the number of qubits required to encode the F features for processing.

2. The quantum logic circuit of claim 1, wherein the nested structure comprises an input layer, at least one intermediate layer, and an output layer.

3. The quantum logic circuit of claim 1 or 2, wherein the plurality of quantum logic gates forms a feature map for encoding multidimensional data onto a quantum state space while reducing the number of qubits.

4. The quantum logic circuit of claim 3, wherein a number of the plurality of quantum logic gates in the preceding layer is higher than the number of the plurality of quantum logic gates in the subsequent layer.

5. The quantum logic circuit of claim 4, wherein the number of qubits for encoding F features is reduced to F / m in each subsequent layer, where m is an integer.

6. The quantum logic circuit of any one of claims 1 to 5, wherein the nested structure reserves a fractional portion of the number of qubits for an ensuing iteration while sending a remaining fractional portion of the number of qubits to a quantum machine learning application.

7. The quantum logic circuit of claim 6, wherein the fractional portion of the number of qubits for an ensuing iteration is one half (m / 2).

8. The quantum logic circuit of claim 6, wherein the fractional portion of the number of qubits for an ensuing iteration is (m-1) / m and the remaining fractional portion of the number of qubits is 1 – ((m-1) / m), where m is an integer.

9. The quantum logic circuit of claim 1, wherein the F features are sequentially input into the input layer and information is sequentially funnelled into progressively fewer qubits in each of at least one intermediate layer and the output layer.

10. The quantum logic circuit of claim 2, wherein the data is mapped non- linearly to the quantum state space.

11. The quantum logic circuit of claim 3, wherein the feature map is a multidimensional feature map.

12. A computer-implemented method for encoding data onto qubits in a quantum state space, the method comprising the operations of: (i) configuring a quantum logic circuit comprising a plurality of processing stages comprising quantum logic gates in a nested structure; (ii) at one of the plurality of processing stages, partitioning the qubits into two subsets of the qubits and performing coherent encoding operations on one of the two subsets of qubits destined for output and sending another of the subset of the qubits to a subsequent processing stage; (iii) at subsequent processing state, partitioning the another of the subset of the qubits into two further subsets of the another of the subset of the qubits, and performing coherent encoding operations on one of the two further subsets of the qubits destined for output and determining whether to send the another of the two further subsets of the qubits for thereby terminating the operations, orto send the another of the two further subsets of the qubits to a next subsequent processing stage and repeating operation (iii) until a determination is made to terminate the operations.

13. The method of claim 12, wherein the quantum logic gates form a feature map for encoding multidimensional data to a quantum state space while minimizing the number of qubits.

14. The method of claim 12, wherein each subsequent layer has fewer quantum logic gates than a preceding layer.

15. The method of claim 14, wherein the number of qubits in each subsequent layer is halved.

16. The method of claim 12, wherein the coherent encoding operations on the qubits comprise encoding features onto the qubits.

17. The method of claim 16, further comprising a layer of entangling gates after each processing stage, wherein the layer of entangling gates acts on the qubits on which features were encoded.

18. The method of claim 17, wherein the layer of entangling gates maps the data non-linearly to the quantum state space and simultaneously performs the partitioning of the qubits into the subsets of the subset of the qubits.

19. The method of any one of claims 12 to 18, wherein the quantum state space is a Hilbert space.

Images