Explore

VQAs performance

Comparison table

Table

Table

Family

Trainability

Efficiency

Scalability

Better results than other methods

Extras

Diagrams

Notes

VQE

small number of variational parameters

large number of measurements required to perform the optimization process

Even if one is able to train, the final cost value will be corrupted by noise. For VQE problems, this is important, since one is ultimately interested in an accurate estimation of the energy

QCC (Qubit Coupled Clusters) and qubit-ADAPT-VQE work directly in the qubit space and are considered more “hardware-efficient” because they are generally more compact and easier to run on NISQ hardware. However, they require additional work to ensure the preservation of all physical symmetries

UCC-based (Unitary Coupled Cluster) methods and ansatz are constructed from fermionic operators and therefore avoid the problems with symmetry preservation. However, the number of multi-qubit gates remains high in this method, which requires the error rates on quantum hardware to significantly improve before such methods can be used

QSE-based (Quantum Subspace Expansion) approaches exhibit higher accuracy from ansatzes prepared with relatively low circuit depth and require fewer numerical parameters to be optimized, but they need extra measurements for Hamiltonian powers, overlap matrix, and/or energy gradient, and may suffer from the linearly dependent many-body basis.

Compared with Quantum Phase Estimation (QPE) algorithm

- Large scale controlled unitaries, required for QPE, cannot be reliably implemented on NISQ devices

-The VQE trades off the depth and number of qubits required under QPE with a higher number of measurements and repetitions of the circuit, as well as the constraints of an approximate ansatz for the state.

- VQE and QPE are likely to provide the most benefit when combined as complementary approaches, offering algorithmic flexibility that can be adjusted depending on the progress of quantum hardware

VQE can be configured with arbitrary ansatzes

Chemistry-inspired ansatzes have a goal of a more careful choice of excitations to include in the ansatz, while hardware-efficient approaches focus on the reduction of the number of multi-qubit gates and using various techniques to choose compact blocks of entangling gates with single-qubit rotational gates more efficiently

When solving the ground state energy problem with a VQE on an application-relevant scale, Natural Gradient appears to be the optimizer of choice for the classical processing step. This holds for both investigated spin chain models and, given the asymptotically vanishing cost overhead of NatGrad for Hamiltonians with many non commuting terms, probably even more so for quantum chemical systems.

Open

QAOA

Finding optimal values γ and β is a hard problem since the optimization landscape in QAOA is non-convex with many local optima.

One can classically compute the cost after sampling ⇒ corruption of final cost by noise is not an important issue.

Provable non-trivial performance guarantees for p= 1

In general even p= 1 QAOA ansatz cannot be efficiently simulated on any classical device

Limited performance on some problems on bounded-degree graphs when the depth is shallow. This limitation may result from the fact that the algorithm cannot “see” the entire graph at low depth. ⇒ one may need the depth to grow with the system size (e.g., p ≥ logN) in order to outperform the best classical algorithms.

As p increases, performance can only improve. Even at p = 1, worst case performance guarantees have been established. These beat random guessing but not the best classical algorithms

MaxCut is a widely studied problem, and there is a polynomial-time algorithm due to Goemans and Williamson which guarantees a certain approximation ratio for all graphs, and it is an open question whether QAOA can efficiently achieve this or beat it

It is believed that classical algorithms like Montanari’s will fail to find near-optimal solutions. It would be interesting to see how the QAOA performs for those problems, and whether it will outperform the classical algorithms

Open

VQLS

To reduce the problem’s dimensionality, an ansatz with a single layer of Ry gate was attempted. This approach does indeed reduce optimization complexity and lead to lower iteration count. However, the quality of the solution deteriorates, showing a shallow (hardware efficient) ansatz is not capable of achieving satisfactory results for this test case and leads to errors hardly acceptable in typical fluid dynamics applications

Gradual ansatz parameters optimization was attempted but resulted in no improvement in overall results, indicating high interconnection between ansatz parameters does not allow independent optimization

While an efficient matrix decomposition was found, ansatz optimization remains one of the main hurdles preventing successful implementation. If no problem-specific ansatz can be devised, optimization complexity and circuit depth increase exponentially, making a quantum advantage unlikely

Improvement was detected when using a non normalized cost function with respect to a normalized one. Although this does not guarantee a solution when the cost is null, this can be easily verified and re-attempted until a solution is found

A linear combination of non-normalized and normalized cost functions did not bring any advantage compared to the normalized case

VQLS can solve simple Finite Element problems for n = 2, but fails to scale to larger problems successfully

The total number of iteration was far larger compared to best classical methods

Open

QVECTOR

Compared to previous optimization-based approaches, the optimization algorithm in QVECTOR is, in principle, scalable

Open

QVS

The impact of physical errors on the simulator’s performance is far lower than in an (optimised) Trotterization protocol (quantum simulation is to approximate the dynamics of a given target Hamiltonian via a sequence of quantum gate) & does not worsen with the duration of the simulation.

Because of the assistance of the classical computer ⇒ can be implemented with quantum circuits of much less depth compared with the canonical Trotterization algorithm.

Can automatically correct some errors induced by the noise in the quantum computer.

Can be parallelized easily. (ability to encode multiple computational results into a quantum state in a single quantum computational step)

Open

QVAE

Ansatz employed for the autoencoder unitary impacts the degree of compression achievable with the autoencoder model

Generally similar performance to their classical limit where the transverse field of the Quantum Boltzmann Machine (QBM) (neural network whose model parameters are inspired by the Transverse Field Ising Model) is absent.

Open

VQC

Scales with the number of qubits ⇒ exponentially fewer learnable parameters than what traditional methods would use

For the VQOCC (~one class classifier)

- The classification performance of VQOCC is comparable to that of OC-SVM (one-class support vector machine) and PCA, although the number of model parameters grows only logarithmically with the data size.

- The quantum algorithm outperformed DCAE (Deep Convolutional AutoEncoder) in most cases under similar training conditions

Open

VQG

The required gradients can be calculated using existing techniques for evaluating gradients of variational functions

We can train the generator with both classical and quantum discriminators ⇒ benefit the implementation of other HQC algorithms, such as VQE

Hybrid quantum-classical architecture proposed in [4] -consisting of a quantum encoding circuit, variational circuit, and measurement decoding - has been shown to be able to approximate non-linear functions

It is an open question whether it can offer a practical advantage with respect to purely classical models for generative learning

Open

There are no rows in this table

⁠

References

Ali, M., & Kabel, M. (2022). A performance study of variational quantum algorithms for solving the Poisson equation on a quantum computer. In arXiv [quant-ph].

http://arxiv.org/abs/2211.14064⁠

⁠

Cappanera, E. (2021). Variational Quantum Linear Solver for Finite Element Problems: a Poisson equation test case.

https://repository.tudelft.nl/islandora/object/uuid%3Adeba389d-f30f-406c-ad7b-babb1b298d87⁠

⁠

Fedorov, D. A., Peng, B., Govind, N., & Alexeev, Y. (2022). VQE method: a short survey and recent developments. Materials Theory, 6(1).

https://doi.org/10.1186/s41313-021-00032-6⁠

⁠

Romero, J., & Aspuru-Guzik, A. (2021). Variational quantum generators: Generative adversarial quantum machine learning for continuous distributions. Advanced Quantum Technologies, 4(1), 2000003.

https://doi.org/10.1002/qute.202000003⁠

⁠

Tilly, J., Chen, H., Cao, S., Picozzi, D., Setia, K., Li, Y., Grant, E., Wossnig, L., Rungger, I., Booth, G. H., & Tennyson, J. (2022). The Variational Quantum Eigensolver: A review of methods and best practices. Physics Reports, 986, 1–128.

https://doi.org/10.1016/j.physrep.2022.08.003⁠

⁠

Farhi, E., Goldstone, J., Gutmann, S., & Zhou, L. (2019). The Quantum Approximate Optimization Algorithm and the Sherrington-Kirkpatrick model at infinite size. In arXiv [quant-ph].

https://quantum-journal.org/papers/q-2022-07-07-759/pdf/⁠

⁠

Park, G., Huh, J., & Park, D. K. (2023). Variational quantum one-class classifier. Machine Learning: Science and Technology, 4(1), 015006.

https://doi.org/10.1088/2632-2153/acafd5⁠

⁠

Johnson, P. D., Romero, J., Olson, J., Cao, Y., & Aspuru-Guzik, A. (2017). QVECTOR: an algorithm for device-tailored quantum error correction. In arXiv [quant-ph].

http://arxiv.org/abs/1711.02249⁠

⁠

Li, Y., & Benjamin, S. C. (2016). Efficient variational quantum simulator incorporating active error minimisation. In arXiv [quant-ph].

http://arxiv.org/abs/1611.09301⁠

⁠

Khoshaman, A., Vinci, W., Denis, B., Andriyash, E., Sadeghi, H., & Amin, M. H. (2018). Quantum Variational Autoencoder. In arXiv [quant-ph].

http://arxiv.org/abs/1802.05779⁠

⁠

Want to print your doc?
This is not the way.

Try clicking the ⋯ next to your doc name or using a keyboard shortcut (

CtrlP

) instead.