PaperlayerView exact revision on arXiv

Source-linked AI summary

Circuit-centric quantum classifiers

Maria Schuld, Alex Bocharov, Krysta Svore, Nathan Wiebe

arXiv:1804.00633v1quant-ph

TL;DR

Near-term quantum devices require resource-limited, error-aware algorithms, while amplitude-encoded quantum machine learning can otherwise demand resource-intensive routines. The paper proposes a low-depth variational classifier with a parametrised circuit, hybrid analytical-gradient training, and a poly-logarithmic parameter count; simulations find performance close to comparable off-the-shelf methods with more tunable parameters.

  • Problem

    Existing amplitude-encoded quantum machine-learning approaches can require resource-intensive algorithms unsuitable for small-scale quantum devices.

  • Method

    The paper uses amplitude encoding, a low-depth parametrised single- and two-qubit model circuit, single-qubit readout, and hybrid quantum-classical analytical-gradient training.

  • Results

    Simulations show results close to off-the-shelf methods with comparable limitations but considerably more tunable parameters.

  • Takeaways & Limitations

    The circuit-centric design provides a near-term quantum machine-learning model with exponentially fewer learnable parameters per qubit than traditional methods.

Abstract

from arXiv · show

The current generation of quantum computing technologies call for quantum algorithms that require a limited number of qubits and quantum gates, and which are robust against errors. A suitable design approach are variational circuits where the parameters of gates are learnt, an approach that is particularly fruitful for applications in machine learning. In this paper, we propose a low-depth variational quantum algorithm for supervised learning. The input feature vectors are encoded into the amplitudes of a quantum system, and a quantum circuit of parametrised single and two-qubit gates together with a single-qubit measurement is used to classify the inputs. This circuit architecture ensures that the number of learnable parameters is poly-logarithmic in the input dimension. We propose a quantum-classical training scheme where the analytical gradients of the model can be estimated by running several slightly adapted versions of the variational circuit. We show with simulations that the circuit-centric quantum classifier performs well on standard classical benchmark datasets while requiring dramatically fewer parameters than other methods. We also evaluate sensitivity of the classification to state preparation and parameter noise, introduce a quantum version of dropout regularisation and provide a graphical representation of quantum gates as highly symmetric linear layers of a neural network.

I. INTRODUCTION

The paper introduces a low-depth variational quantum classifier that uses amplitude encoding, a parametrised quantum model circuit, and single-qubit measurement for supervised binary classification. Its circuit-centric design targets near-term devices with poly-logarithmically many learnable parameters and hybrid quantum-classical training.

  • Near-term quantum devices motivate algorithms using limited operations and qubits without costly error correction.
  • The classifier encodes inputs into quantum amplitudes, applies a parametrised circuit, and infers binary predictions from a single-qubit measurement.
  • The proposed model circuit uses parametrised single- and controlled-single-qubit gates, with learnable parameters growing poly-logarithmically in input dimension.
  • Training uses a hybrid scheme that estimates analytical gradients from slight circuit variations and updates classical parameters on a computer.
  • The circuit can be viewed as a neural network with unitary linear layers, measurement-based nonlinear processing, and classical thresholding.
  • Simulations report reasonable performance compared with out-of-the-box methods, while the classifier can overfit SONAR and WINE datasets.

A. State preparation

State preparation maps classical inputs into quantum-state amplitudes, primarily through amplitude encoding. The approach requires dimensional and normalization conditions, while preparation cost can remain a practical resource constraint.

  • Amplitude encoding associates an input vector with the amplitudes of a 2^n-dimensional quantum state.
  • Inputs must be normalized to unit length, and non-power-of-two dimensions can be padded with zero features.
  • Padding to an exact power-of-two dimension can create an ancillary space and introduce non-informative constant features.
  • Preparing an amplitude-encoded state can require a circuit linear in the number of input features, although exploitable structure may permit polylogarithmic dependence.
  • The paper notes that approximate state preparation may reduce circuit resources at the expense of input error.
  • Preparing multiple copies of an encoded state implements a tensorial feature map into a higher-dimensional space.

B. The model circuit

The model circuit is a parametrised unitary built from single- and two-qubit gates. Its restricted depth and gate parametrisation reduce resources while limiting the set of reachable states.

  • The model circuit applies a parametrised unitary Uθ to the encoded feature state.
  • The circuit is decomposed into single-qubit and controlled single-qubit gates, with imprimitive two-qubit gates supplying entangling capability.
  • Single-qubit gates together with imprimitive two-qubit gates can generate arbitrary n-qubit unitaries to arbitrary precision.
  • Each trainable single-qubit gate can be represented with three learnable parameters after omitting an unmeasurable global phase.
  • The parametrisation avoids an additional condition on model parameters but may have unfavorable convergence near optima.

C. Read out and postprocessing

The classifier estimates a single-qubit measurement probability by repeated circuit executions, adds a learnable bias, and thresholds the resulting value for binary prediction.

  • Measurement: Repeated circuit executions estimate the probability that the first qubit is measured in state 1.The estimate uses S samples from measurements of the first qubit.
  • Postprocessing: The continuous model output is formed by adding a learnable bias b to the measured probability.
  • Postprocessing: Thresholding the continuous output at 0.5 produces the binary classifier prediction.
  • Measurement: The measurement can also be represented as the expectation value of a σz operator acting on the first qubit.
  • Circuit example: 100 parameters classify inputs of 256 dimensions in the illustrated 8-qubit circuit architecture.

III. CIRCUIT ARCHITECTURES

The architecture uses strongly entangling code blocks while reducing redundant controlled-gate parameters, preserving a low-depth circuit with a compact parameterization.

  • A. Strongly entangling circuits: Constraining the circuit depth to polynomial in n enables a number of elementary operations that grows polylogarithmically with data dimension.This low-depth objective restricts the reachable subset of the Hilbert space.
  • A. Strongly entangling circuits: Strongly entangling circuits can reach wider regions of Hilbert space and project class-labeled inputs onto measurement-relevant subspaces.
  • A. Strongly entangling circuits: Each code block applies single-qubit gates followed by controlled gates whose connectivity is determined by the control range r.
  • A. Strongly entangling circuits: When r is relatively prime to n, a code block can entangle or unentangle all n qubits.
  • A. Strongly entangling circuits: A four-qubit example produces a completely mixed marginal state across two subsystems, demonstrating strong entanglement.
  • B. Optimising the architecture: Circuit redundancy can be reduced to roughly 5 n parameters, with controlled phases, X-rotations, and single-qubit gates contributing separate parameter groups.
  • B. Optimising the architecture: The reduction rewrites controlled gates through diagonalization, commutation, and merging of updated single-qubit gates across layers.

C. Graphical representation of gates

The paper represents quantum gates as highly symmetric neural-network-like linear layers, with controls determining connectivity and breaking some parameter tying.

  • Graphical representation: A quantum circuit can be viewed as a sequence of linear layers with equal numbers of units in successive hidden layers.
  • Graphical representation: The qubit and control positions determine which units are connected and which weights are tied in each gate-layer.
  • Graphical representation: In the gate diagrams, solid lines denote unit weights, other line styles denote variable weights, and matching styles indicate shared weights.
  • Graphical representation: A single-qubit gate connects variable sets with shared weights, while a controlled gate replaces some ties with identities.
  • Graphical representation: Although the layers are linear in their inputs, their matrix entries depend nonlinearly on the circuit parameters.

IV. TRAINING

Training combines quantum computation of model outputs and analytical gradient estimates with classical parameter updates, using single-sample stochastic gradient descent to limit state-preparation cost.

  • Training scheme: The training procedure combines classical parameter updates with quantum extraction of gradient estimates.
  • Cost function: A standard least-squares objective evaluates each parameter configuration and bias on the training data.
  • Cost function: Regularization could be added classically through L1 or L2 terms, but the paper does not include regularization.
  • Parameter updates: Gradient descent updates each circuit parameter and the bias using derivatives of the cost function and learning rate η.
  • Stochastic gradient descent: 33The method avoids encoding an entire batch in superposition because general batch state preparation would scale as O(BN).
  • Hybrid training: The QPU computes outputs and gradients, while classical processing updates parameters at each gradient-descent step.
  • Stochastic gradient descent: Single-batch gradient descent uses one randomly sampled training input per iteration and can have favorable convergence properties when much data is available.

B. Hybrid gradient descent scheme

The training scheme combines quantum measurements with classical parameter updates, while gradient estimation must address derivatives of the circuit's unitary operator.

  • The prediction uses the probability of measuring the first qubit in state 1, represented through the expectation value of σz.
  • For a circuit parameter µ, the model gradient requires differentiating the unitary circuit contribution to the prediction.
  • When only one gate depends on µ, its circuit derivative is embedded among identity operators; tied parameters require the product rule.
  • The gradient of a unitary is not necessarily unitary, so its derivative cannot directly produce a quantum state through ordinary quantum evolution.

C. Classical linear combinations of unitaries

The classifier represents circuit derivatives as classical linear combinations of unitary circuits, allowing gradient estimates from repeated quantum runs and classical postprocessing.

  • The architecture represents every circuit derivative as a linear combination of unitaries.
  • Classical linear combinations avoid coherent superposition by running the relevant circuits several times and collecting their outputs for classical postprocessing.
  • Single-qubit gate derivatives use parameter shifts, while controlled-gate derivatives may require linear combinations of controlled gates.
  • For α, the derivative uses a shifted version of the same gate; for β and γ, it uses linear combinations with shifted parameters.
  • The resulting gradient is a weighted sum of predictions from modified parameter vectors, with J equal to 2 or 4 for untied one- or two-qubit gates.
  • An interference routine estimates the real overlaps needed for these weighted sums using an ancilla-controlled circuit and repeated measurements.

D. Dropout

The classifier can overfit despite its small parameter space, and a quantum-ready dropout procedure is proposed to smooth the fit and improve generalization.

  • The architecture can fit smaller training sets perfectly while still producing significant generalization errors on held-out data.
  • Dropout randomly selects and measures a qubit, removes it for Ndropout parameter-update epochs, then re-adds it before selecting another qubit or none.
  • The procedure generally increases training error while often reducing generalization error by smoothing the model fit.
  • Freezing one randomly chosen qubit is analogous to removing half the nodes from a neural-network hidden layer when dropout probability p = 0.5.

1. Circuit depth and width

The classifier uses logarithmically many qubits for amplitude-encoded inputs and has a resource-light model circuit, but state preparation can dominate costs and noise remains consequential at large perturbations.

  • 1. Circuit depth and width: d⌈log2 N⌉ qubits suffice for N-dimensional inputs with tensorial feature-map degree d; d = 1 processes 1000-dimensional inputs with n = 10 qubits.
  • 1. Circuit depth and width: The model circuit requires polynomially many parametrised controlled single-qubit gates, while state preparation is the main circuit-depth bottleneck.
  • 1. Circuit depth and width: Each parametrised single-qubit gate can be decomposed into O(log 1/δ) elementary gates while achieving fidelity at least 1 −δ.
  • 1. Circuit depth and width: General state preparation can require ccn2^n CNOT gates and csgl2^n single-qubit gates, making lower-dimensional datasets advisable without error correction.
  • 1. Circuit depth and width: Estimating the measured output to error ϵ with probability greater than 2/3 requires O(Var(σz)/ϵ^2) samples, or O(1/ϵ) repetitions with amplitude estimation and greater depth.
  • 3. Parameter noise: Unitary operations prevent parameter and input imperfections from being amplified across the circuit; the final-state defect is bounded by 4Lδ in the worst case.
  • 3. Parameter noise: At 0.1% parameter noise, classification was unaffected in about 60% of test runs; at 10%, mean test-error change reached 60.2%.
  • 3. Parameter noise: The observations suggest these classifiers may operate on small quantum computers without strong quantum error correction.

V. SIMULATIONS AND BENCHMARKING

The simulations benchmark the circuit-centric quantum classifier against classical models using six standard datasets, varied neural-network architectures, support vector machines, and parameter-count comparisons.

  • Datasets and preprocessing: The study evaluates the classifier on six standard benchmark datasets, including binary and multi-class classification tasks.CANCER and SONAR are binary; WINE, SEMEION, and MNIST require multi-class classification.
  • Datasets and preprocessing: Inputs are padded to the nearest power-of-two dimension, normalized to unit norm, and amplitude-encoded using n = ⌈log2(N)⌉ qubits.MNIST vectors are coarse-grained to dimension 256; other datasets receive non-informative padding.
  • Quantum classifier: The quantum classifier uses one to three entangling layers, with 3n + 2 to 18n + 2 real trainable parameters.The selected architecture minimizes training error while reducing overfitting.
  • Benchmark models: Neural-network benchmarks include MLPlin with an N-sized linear hidden layer and MLPshal and MLPdeep with hidden layers of size ⌈log2 N⌉.MLPdeep adds a second nonlinear hidden layer; all use a logistic output layer.
  • Benchmark models: The comparison also includes support vector machines with polynomial kernels and counts trainable parameters across models and datasets.The quantum classifier is compared with polynomial-kernel SVMs while accounting for model architecture and dataset size.

3. Results

Across benchmark simulations, the quantum classifier outperforms the tested low-degree polynomial-kernel SVMs and achieves performance comparable to neural networks with more parameters, while retaining a logarithmic parameter scaling.

  • Benchmark results: The QC model performs significantly better than SVMpoly1 and SVMpoly2 across all datasets.Polynomial-kernel SVMs with degrees d = 6 to d = 8 performed better than the MLP models in additional simulations.
  • Benchmark results: The QC has slightly worse test errors than MLPshal and MLPdeep, with mixed success against MLPlin, but remains comparable to MLP models training many more parameters.The QC overfits SONAR and WINE, and dropout regularization reduces this issue.
  • Parameter scaling: The classifier’s number of learnable parameters scales with the number of qubits, allowing qubit-wise exponentially fewer parameters than traditional methods.Preliminary simulations achieved results close to off-the-shelf methods with comparable limitations but considerably more tunable parameters.
  • Model properties: The explored quantum classifiers are weakly nonlinear because measurement and thresholding provide the main nonlinearity after linear reversible circuit evolution.Measurement probabilities are approximately quadratic in the final-state amplitudes.
  • Limitations and future work: Higher-degree polynomial boundaries could be explored by encoding multiple data copies, but this would require vastly more resources for circuit simulation.The authors leave these experiments for future work.
  • Limitations and future work: The paper identifies overfitting, limited larger-dataset benchmarks, and unresolved questions about feature maps, convergence, and representational power.The authors call for further numerical and theoretical studies.
Loading 1804.00633v1…