PaperlayerView exact revision on arXiv

Source-linked AI summary

Avoiding local minima in variational quantum eigensolvers with the natural gradient optimizer

David Wierichs, Christian Gogolin, Michael Kastoryano

arXiv:2004.14666v2quant-ph

TL;DR

VQE optimization requires methods that can find desirable minima efficiently as system size and circuit expressivity grow. The paper compares BFGS, ADAM, and regularized NatGrad on TFIM, XXZ, and overparametrized ansätze, finding that NatGrad is generally more reliable but substantially more expensive per epoch. The results show that optimizer choice and ansatz parametrization both require careful control.

  • Problem

    VQEs need classical optimizers that reliably locate desirable minima with few quantum-computer calls as system size and ansatz complexity increase.

  • Method

    The study compares BFGS, ADAM, and regularized Natural Gradient Descent on TFIM and XXZ VQE circuits, including overparametrized symmetry-breaking ansätze.

  • Results

    NatGrad reliably converges across tested system sizes, while BFGS and ADAM increasingly encounter convergence failures; overparametrization worsens all optimizers, especially BFGS and ADAM.

  • Takeaways & Limitations

    VQE performance depends strongly on both optimizer choice and ansatz parametrization, with NatGrad promising higher reliability despite its expensive per-epoch cost.

Abstract

from arXiv · show

We compare the BFGS optimizer, ADAM and Natural Gradient Descent (NatGrad) in the context of Variational Quantum Eigensolvers (VQEs). We systematically analyze their performance on the QAOA ansatz for the Transverse Field Ising Model (TFIM) as well as on overparametrized circuits with the ability to break the symmetry of the Hamiltonian. The BFGS algorithm is frequently unable to find a global minimum for systems beyond about 20 spins and ADAM easily gets trapped in local minima. On the other hand, NatGrad shows stable performance on all considered system sizes, albeit at a significantly higher cost per epoch. In sharp contrast to most classical gradient based learning, the performance of all optimizers is found to decrease upon seemingly benign overparametrization of the ansatz class, with BFGS and ADAM failing more often and more severely than NatGrad. Additional tests for the Heisenberg XXZ model corroborate the accuracy problems of BFGS in high dimensions, but they reveal some shortcomings of NatGrad as well. Our results suggest that great care needs to be taken in the choice of gradient based optimizers and the parametrization for VQEs.

I. INTRODUCTION

The paper compares classical and natural-gradient optimizers for VQEs, focusing on scalable TFIM and XXZ settings, ansatz expressivity, and overparametrization. NatGrad is generally more reliable, while BFGS and ADAM encounter convergence problems that worsen with system size and redundant circuit layers.

  • I. INTRODUCTION: The study separates optimizer behavior from ansatz expressiveness by using TFIM and XXZ models whose system sizes can be varied and whose ground-state structure is tractable.The selected models allow systematic scaling studies and help distinguish optimization failures from insufficient ansatz expressiveness.
  • I. INTRODUCTION: NatGrad consistently finds global minima across tested TFIM system sizes, using fewer epochs than ADAM when ADAM converges, but at substantially higher per-epoch cost.Tikhonov regularization helps prevent large updates and escape from barren-plateau-related failures.
  • I. INTRODUCTION: Overparametrization with redundant symmetry-breaking layers makes optimization harder rather than easier, with BFGS and ADAM failing more often while NatGrad remains comparatively resilient.The added layers do not improve performance and their effects cannot be reliably mitigated by increasing ADAM's iteration budget or reducing its learning rate.
  • I. INTRODUCTION: XXZ tests reproduce BFGS's high-dimensional accuracy problems but show that NatGrad is not uniformly reliable, motivating further investigation.The paper notes that NatGrad's flat intermediate curves can obscure whether difficult phases represent slow progress or convergence to local minima.
  • I. INTRODUCTION: BFGS fails systematically above N = 20, whereas ADAM can converge in larger spaces only with suitably small learning rates and rapidly increasing epoch counts.ADAM also exhibits a learning-rate-dependent transition beyond which runtimes become unpredictable or exceed the iteration budget.
  • I. INTRODUCTION: Because NatGrad's Fubini-matrix cost is especially high for spin chains, its reliability advantage may be more economically favorable in systems with more favorable Hamiltonian scaling.The relative per-epoch overhead can be smaller for chemical systems with at least quadratic scaling of the Hamiltonian term count.

B. Overparametrization by adding Y layers

Adding redundant Pauli Y-rotation layers preserves the ground state but makes optimization substantially harder, especially for BFGS and ADAM. NatGrad is more resilient, although it remains the most expensive optimizer at runtime.

  • Symmetry-breaking overparametrization: Overparametrized TFIM circuits reduce optimization success because the added Y rotations break the Hamiltonian symmetry and must be deactivated at the optimum.Successful runs set the additional rotation parameters to zero; failed runs converge locally without doing so.
  • Experimental outcome: The extended-circuit experiments produce a clear separation between runs reaching global minima and runs converging locally, without intermediate precisions caused by the iteration budget.Figure 3 reports achieved precision and the fraction of successful optimizations for one or two added Y layers.
  • Optimizer performance: With two added Y layers, BFGS succeeds in fewer than 50% of runs for multiple system sizes, while ADAM observes no successful runs for N ≥14.BFGS degradation is stronger with two layers, and ADAM remains trapped in local minima even without exhausting the iteration budget.
  • Optimizer performance: NatGrad has the highest success rate for most extended circuits, and its success rate never falls below 60%.Only a few system sizes show local convergence for NatGrad with one or two added layers.
  • Runtime: NatGrad costs the most per epoch, but its smaller iteration count partly compensates for that expense on small systems.The runtime estimates include unsuccessful instances and distinguish successful ADAM minimizations.
  • Interpretation and limitation: The authors caution that strong fluctuations across system sizes require more optimization repetitions to establish systematic scaling behavior.The observed degradation is nevertheless attributed to extending the ansatz beyond the original symmetry sector.

C. Results on the Heisenberg model

XXZ tests reproduce BFGS accuracy problems and ADAM runtime difficulties at moderate parameter counts, while NatGrad is less reliable than in the TFIM. The results limit direct generalization of NatGrad’s TFIM performance.

  • XXZ optimizer results: ADAM reaches the target accuracy of 10^-5 but exhibits an abrupt increase in iteration count, whereas BFGS starts failing for medium-sized systems.The XXZ experiments use an ansatz with n = 3N parameters and initialize each optimizer from 20 points near zero.
  • XXZ optimizer results: In the XXZ model, BFGS begins failing significantly near n = 24 parameters, while ADAM’s runtime jumps abruptly at n = 24 and n = 36.Comparable transitions occur at similar parameter counts in the TFIM, despite differing Hilbert-space dimensions.
  • NatGrad behavior: NatGrad is less performant on XXZ because some runs are interrupted during phases of small updates, possibly reflecting local convergence or an overly small learning rate.Reducing its learning rate can prevent convergence in instances that previously succeeded.
  • Accuracy assessment: The failed-run precision gap is inconsistent across system sizes, but NatGrad’s deviation from the target precision is smaller than BFGS’s.Extending the gap observed at N = 8 and N = 10 would classify many BFGS runs as unsuccessful.
  • Interpretation: Across models, parameter-space size appears to govern BFGS performance and ADAM runtime more directly than the Hilbert-space dimension.The authors state that NatGrad’s reliable TFIM behavior cannot necessarily be generalized to other spin-chain models or Hamiltonian classes.

III. METHODS

VQE combines parametrized quantum circuits with classical optimization to prepare ground states of target Hamiltonians. Its central methodological challenge is balancing ansatz expressivity against optimizer efficiency.

  • VQE framework: A VQE prepares a parametrized ansatz state on a quantum computer and measures the Hamiltonian energy as the objective function.The classical optimizer receives access to this quantum-computed objective.
  • VQE framework: The classical stage can use measured auxiliary quantities, such as energy gradients, to implement more sophisticated optimization methods.Modified circuit preparations provide access to these quantities.
  • Design challenges: VQE applications require a circuit expressive enough to contain the ground state but not so expensive that it becomes impractical, together with an optimizer capable of searching its parameter space.The paper identifies these as the expressivity and efficiency challenges of VQE.
  • Ansatz construction: The ansatz is constructed by applying parametrized unitaries {U_j(θ_j)} to an initial product state.The work uses translationally invariant layers of one- and two-qubit rotations with parameters typically initialized near zero.
  • Circuit structure: The circuit layers use Pauli rotation gates whose commuting structure can simplify implementation, although full circuit unitaries need not commute.Periodic boundary conditions and implicit identity tensor factors are assumed in the example construction.

1. A selection of ansatz classes

The paper reviews fixed and adaptive ansatz classes, emphasizing Trotterized QAOA circuits and methods that grow circuits during optimization. It excludes direct minimization because of high-dimensional cost.

  • QAOA: QAOA alternates cost- and mixing-Hamiltonian unitaries to form a VQE ansatz with variational time parameters.For noncommuting quantum Hamiltonians, the cost blocks are commonly Trotterized for practical implementation.
  • QAOA: The study uses a modified, Trotterized QAOA ansatz for the TFIM because it is more readily implementable than exact Hamiltonian evolution.This ansatz has been studied previously and serves as the starting point for the investigations.
  • Adaptive ansätze: Adaptive ansätze such as ADAPT-VQE iteratively append gates from a pool and reoptimize the circuit parameters after each addition.The optimized parameters also inform subsequent gate selection and initialization.
  • Adaptive ansätze: The paper does not use adaptive schemes and raises doubts about their reliability based on its findings about optimizer stability and overparametrization.This is presented as a limitation or concern rather than a demonstrated result for adaptive methods.
  • Optimization strategy: Direct optimization is omitted because global-search strategies become exponentially expensive with parameter dimension and appear infeasible for relevant VQE sizes.A 15-dimensional two-value grid already requires 2^15 > 3 · 10^4 function evaluations.

2. First-Order Gradient Descent

First-order methods improve basic gradient descent with adaptive learning rates, momentum, or curvature-informed searches, but retain optimization trade-offs in VQE landscapes.

  • Gradient descent: Gradient descent trades convergence speed against stability: small learning rates slow optimization, whereas large rates can cause overshooting and oscillations.The method follows the steepest descent direction when the learning rate is sufficiently small.
  • ADAM: ADAM combines adaptive componentwise learning rates with momentum to avoid suppressed learning and overcome some local minima.Its update uses exponentially decayed averages of past gradients and squared gradients.
  • ADAM: ADAM represents local first-order optimizers because its advanced features have made it successful across many tasks.The paper notes that more basic gradient-based methods can nevertheless be advantageous in some applications.
  • BFGS: BFGS approximates the Hessian from first-order information and performs global line searches along Hessian-transformed gradient directions.Its line searches make it nonlocal, while its higher-order information remains locally estimated.

4. Natural Gradient Descent

Natural Gradient Descent uses the ansatz’s Fubini–Study metric to precondition updates, with Tikhonov regularization improving numerical stability at substantial measurement cost.

  • Natural-gradient update: NatGrad constructs the Fubini–Study metric of the ansatz class before updating parameters, using geometric information rather than only the energy gradient.The metric is the quantum analogue of the classical Fisher information matrix.
  • Regularization: Tikhonov regularization adds a small diagonal constant to F before inversion, limiting updates caused by very small eigenvalues.Without regularization, the learning rate may need to be unpredictably small during initial steps.
  • Computational cost: For n parameters, constructing F requires 1/2(n^2 + 3n) pairwise overlaps, and circuit symmetries can reduce the number of distinct evaluations.Each overlap may require one or many individual circuit evaluations, depending on the ansatz gates.
  • Computational cost: Fubini–Study matrix construction is expected to take much longer than matrix inversion because it requires many quantum circuit evaluations.This reverses the usual cost relationship seen in typical classical machine-learning problems.
  • Applicability: NatGrad’s high cost is less problematic for VQEs with relatively few parameters and beneficial circuit symmetries.The paper frames this as an expectation for the studied setting rather than a universal cost guarantee.

5. Optimization cost

The paper compares VQE optimization costs per epoch by separating gradient, Fubini-metric, sampling, and implementation contributions under explicit scaling assumptions.

  • Gradient cost: Gradient evaluation trades precision against cost: analytic gradients use an ancilla and scale with Kn, while finite-difference variants have prefactors 2n, n+1, or 2.The alternatives are symmetric finite difference, asymmetric finite difference, and SPSA, respectively.
  • Cost comparison: Per-epoch costs are used to compare optimizers beyond simulation time and to estimate quantum-computer runtime when convergence epochs are known.BFGS line-search evaluations remain difficult to predict generically.
  • NatGrad cost: NatGrad adds Fubini-metric construction to gradient cost, whereas inversion of F is treated as negligible in the displayed comparison.The analysis assumes measurement samples NM and Na for energy-related and Fubini-matrix estimates.
  • Model dependence: Translation symmetry in the spin-chain models keeps KH small, making Fubini-matrix construction a relatively large part of NatGrad’s cost.For chemical systems with at least quadratic KH scaling, NatGrad’s relative additional epoch cost may be smaller.
  • TFIM benchmark: The TFIM ground state is analytically available through a free-fermion mapping, supporting exact benchmarks and more efficient fermionic simulations.The fermionic representation stores 2r complex numbers and uses smaller matrix-vector multiplications than the full qubit picture.
  • TFIM benchmark: For t = 0, the modified QAOA circuit can exactly prepare the ground state if and only if p ≥ r; for t ≠ 0, the corresponding claim has only numerical and non-rigorous support.The parameter-count argument compares 2p independent parameters with 2r constraints but does not establish solvability for the nonlinear problem.

2. Heisenberg XXZ Model

The XXZ model provides a more application-like benchmark because its ground state is not known to be contained in a finite gate sequence. The study therefore uses symmetry-preserving, first-order Trotterized circuits initialized from an antiferromagnetic state.

  • 2. Heisenberg XXZ Model: The XXZ benchmark uses symmetry-preserving circuit layers because no finite gate sequence is known to contain the ground state.This setup models the application case more closely than the exactly solvable TFIM benchmark.
  • 2. Heisenberg XXZ Model: The chosen ansatz is first-order Trotterized unitary evolution under the system Hamiltonian, applied to an antiferromagnetic ground state.
  • 2. Heisenberg XXZ Model: The initial state is selected by translation symmetry: symmetric when N mod 4 = 0 and antisymmetric when N mod 4 = 2.
  • 2. Heisenberg XXZ Model: The Trotterized circuit was more successful at finding the ground state than the QAOA circuit.
  • 2. Heisenberg XXZ Model: The ansatz preserves the relevant magnetization sector even though the YY interaction terms do not generally preserve Z-basis magnetization.

D. Simulation Details

The simulations compare optimizer behavior across TFIM and XXZ settings using controlled parameter choices and benchmark conditions. The reported results show BFGS and ADAM limitations, while regularized NatGrad is more reliable but more expensive.

  • D. Simulation Details: BFGS becomes increasingly likely to get stuck in local minima as system size grows, despite being quick and reliable for small systems.The authors suspect its line-search information is less helpful in sparse, high-dimensional parameter spaces.
  • D. Simulation Details: ADAM can find global minima for parameter spaces up to 42 with sufficiently small learning rates, but its epoch count rises rapidly.Choosing the learning rate requires balancing a threshold-related runtime increase against slower optimization below the threshold.
  • D. Simulation Details: Regularized NatGrad reliably converges to global minima in all tested system sizes within fewer epochs, but its per-epoch cost is high.The Fubini-matrix calculation particularly increases estimated runtime for spin-chain systems.
  • D. Simulation Details: Overparametrization with symmetry-breaking rotation layers worsens BFGS performance, producing failures even for some small systems and fluctuating results as layers increase.The simulation cost limited the maximum system size tested, and stronger overparametrization was not expected to resolve the problem.
  • D. Simulation Details: ADAM is also highly susceptible to the extra degrees of freedom, contrasting with the usual role of overparametrization in classical machine learning.The authors identify this as a possible fundamental difference between classical machine learning and VQEs.

Appendix A: Exact solution of the TFIM

The appendix derives an exact TFIM solution by transforming the Hamiltonian into fermionic modes. Pairwise mode structure then enables a direct-sum representation and subspace-wise ground-state calculation.

  • Appendix A: Exact solution of the TFIM: The derivation begins with linear combinations of operators and applies a Fourier transformation with shifted momenta.The transformed modes are then relabeled using mode-dependent angles.
  • Appendix A: Exact solution of the TFIM: The transformed operators satisfy fermionic anticommutation relations, providing the operator basis for the exact solution.
  • Appendix A: Exact solution of the TFIM: The Hamiltonians generating the TFIM and QAOA unitaries are transformed using the same fermionic representation.The transformed Hamiltonians are obtained after applying the stated operator identities.
  • Appendix A: Exact solution of the TFIM: Boundary-condition and parity effects are handled through a gauge factor and an additional phase transformation, including the odd-N case.
  • Appendix A: Exact solution of the TFIM: The TFIM Hamiltonian is transformed into a fermionic operator basis in which interacting momentum-mode pairs are decoupled from one another.This reveals the model's simple structure and allows the Hamiltonian to be written as a direct sum.
  • Appendix A: Exact solution of the TFIM: The ground state is computed separately in each fermionic subspace after the Hamiltonian is decomposed into independent mode pairs.The circuit simulation likewise decomposes into a direct sum of two-dimensional spaces, where the evolution operators act as Bloch-sphere rotations.

TFIM

The supplied passage states that E′ is an eigenvalue of H′.

  • TFIM: E′ is the eigenvalue associated with H′.

Appendix B: Learning rate influence on ADAM performance

ADAM’s learning rate strongly affects runtime and the system size at which convergence becomes problematic. Lower learning rates delay the threshold but increase iteration costs for smaller systems.

  • Reducing η shifts the system-size threshold beyond which ADAM fails by delaying local convergence to larger systems.The threshold shift is shown for ADAM initialized at 20 distinct points near zero.
  • The fitted small-system scaling exponents are 2.3, 2.3, 1.9, and 1.4 for the shown learning rates in descending order.The fits use filtered data and are not intended to describe the entire dataset.
  • For fixed η, ADAM’s epoch count grows polynomially with system size before a threshold N*, after which it can exceed 5·10^4 iterations.Beyond N*, excessive iteration counts occur both when ADAM succeeds and when it becomes trapped in a local minimum.
  • Lowering η substantially increases epoch counts at smaller system sizes despite preserving convergence there.The smaller scaling exponent at lower η is offset by a larger prefactor, increasing costs before the threshold jump.
Loading 2004.14666v2…