Meta-VQE.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Meta-VQE algorithm (demo) <img src=\"img/ML_logo.png\" width=\"20%\" align=\"right\">\n",
    "_______________________________________________________\n",
    "\n",
    "_Authors:_ Alba Cervera-Lierta, Jakob S. Kottmann, Alán Aspuru-Guzik.\n",
    "_Originally published at:_ https://github.com/aspuru-guzik-group/Meta-VQE\n",
    "\n",
    "This notebook presents a demo code to reproduce the results of the article \"Meta-Variational Quantum Eigensolver: Learning energy profiles of parameterized Hamiltonians for quantum simulation\", [PRX Quantum 2, 020329 (2021)](https://doi.org/10.1103/PRXQuantum.2.020329) (eprint: [arxiv:200913545](http://arxiv.org/abs/2009.13545)).\n",
    "\n",
    "This demo simulates a meta-VQE for the 1D XXZ model with external field. It also shows the comparison with a standard VQE, opt-meta-VQE, GA-VQE and opt-GA-VQE algorithms detailed in the main article. \n",
    "\n",
    "For computational reasons, the notebook is set to simulate a $n=4$ spin chain and a meta-VQE with $2$ encoding layer and $1$ processing layers. Results shown in the main article can be obtained by adjusting the number of qubits and layers. Article results can be found in \"data\" (link) folder in this repository.\n",
    "\n",
    "The code is written using [_Tequila_](https://github.com/aspuru-guzik-group/tequila) language and [_qulacs_](https://github.com/qulacs/qulacs) simulator as a default backend.\n",
    "\n",
    "__Table of contents:__\n",
    "1. [Model and PQC ansatz](#Model-and-PQC-ansatz)\n",
    "    1. [Hamiltonian: XXZ with external field](#Hamiltonian:-XXZ-with-external-field)\n",
    "    1. [Parametrized Quantum Circuit](#Parametrized-Quantum-Circuit)\n",
    "1. [Main code: meta-VQE algorithm](#Main-code:-meta-VQE-algorithm)\n",
    "    1. [Meta-VQE](#Meta-VQE)\n",
    "        1. [Training](#Training)\n",
    "        1. [Test](#Test)\n",
    "    1. [Comparison with other algorithms](#Comparison-with-other-algorithms)\n",
    "        1. [Standard VQE](#Standard-VQE)\n",
    "        1. [Globally-averaged VQE (GA-VQE)](#Globally-averaged-VQE-(GA-VQE))\n",
    "        1. [VQE with meta-VQE initialization (opt-meta-VQE)](#VQE-with-meta-VQE-initialization-(opt-meta-VQE))\n",
    "        1. [VQE with GA-VQE initialization (opt-GA-VQE)](#VQE-with-GA-VQE-initialization-(opt-GA-VQE))\n",
    "    1. [Plots](#Plots)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import all we need\n",
    "# tested with tq git revision: ab252adc4090465ff47f182de32d69b84d7fc13f\n",
    "import tequila as tq\n",
    "import numpy as np\n",
    "from numpy import random\n",
    "import matplotlib.pyplot as plt\n",
    "import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Seed generator from alphabetic string\n",
    "def seed_gen(string):\n",
    "    num_str = [ord(letter) - 96 for letter in string]\n",
    "    # seed must be between 0 and 2**32 - 1\n",
    "    return(np.mod(int(''.join(map(str,num_str))),2**32 - 1))\n",
    "\n",
    "seeds = ['matterlab', 'alba', 'jakob', 'alan']\n",
    "\n",
    "s = 0 # default seed, used in the main article results\n",
    "random.seed(seed_gen(seeds[s])) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model and PQC ansatz\n",
    "\n",
    "First, we will define the Hamiltonian and circuit ansatz used in this work. These functions can be easily modified to accomodate other hamiltonians or ansatzes.\n",
    "\n",
    "### Hamiltonian: XXZ with external field\n",
    "\n",
    "The spin Hamiltonian used is the 1D antiferromagnetic XXZ spin chain with external field $\\lambda$ and periodic boundary conditions:\n",
    "$$ \\mathcal{H}=\\sum_{i=1}^{n}\\sigma_{i}^{x}\\sigma_{i+1}^{x}+\\sigma_{i}^{y}\\sigma_{i+1}^{y}+\\Delta\\sigma_{i}^{z}\\sigma_{i+1}^{z} + \\lambda \\sum_{i=1}^{n}\\sigma_{i}^{z}.$$\n",
    "To check the accuracy of the results obtained, we also compute the exact ground state energy of this Hamiltonian by diagonalizing it; we called that function `exact`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def HXXZ(num_qubits,delta,lam):\n",
    "    # PBC\n",
    "    ham = tq.paulis.X(num_qubits-1)*tq.paulis.X(0) \n",
    "    ham += tq.paulis.Y(num_qubits-1)*tq.paulis.Y(0) \n",
    "    ham += delta*tq.paulis.Z(num_qubits-1)*tq.paulis.Z(0)\n",
    "    ham += lam*tq.paulis.Z(num_qubits-1)\n",
    "    for i in range(num_qubits-1):\n",
    "        ham += tq.paulis.X(i)*tq.paulis.X(i+1)\n",
    "        ham += tq.paulis.Y(i)*tq.paulis.Y(i+1)\n",
    "        ham += delta*tq.paulis.Z(i)*tq.paulis.Z(i+1)\n",
    "        ham += lam*tq.paulis.Z(i)\n",
    "    return(ham)\n",
    "def exact(num_qubits,delta,lam):\n",
    "    ham_matrix = HXXZ(num_qubits,delta,lam).to_matrix()\n",
    "    energ = np.linalg.eigvals(ham_matrix)\n",
    "    return(min(energ))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Parametrized Quantum Circuit\n",
    "\n",
    "The meta-VQE algorithm needs a Parameterized Quantum Circuit (PQC) both for the encoding and processsing parts. We use a unique ansatz for both of them, where the parameters appear in the single-qubit rotational gates. The ansatz is divided in layers, each of them including single-qubit gates on each qubit plus CNOT gates between neighbouring pairs. \n",
    "\n",
    "First, we define the general single-qubit unitary gater `Ugen`,\n",
    "$$ U_{gen} = R_{z}(\\phi)R_{y}(\\theta)R_{z}(\\varphi). $$\n",
    "\n",
    "The `PQC` depends on the number of qubits, layers, Hamiltonian argument and the optimization variable name. If the argument is zero (which will be the case for the processing layers, where there is no encoding), then it only uses `Ugen` gates with two optimization angles. On the contrary, if the arguments are different from zero (corresponding to the encoding layers), the `Ugen` gate angles will be defined as\n",
    "$$ R_{z}(w_{il}^{(1)}\\Delta + \\phi_{il}^{(1)}) R_{y}(w_{il}^{(2)}\\Delta + \\phi_{il}^{(2)}), $$\n",
    "where $i$ and $l$ correspond to the qubit and layer respectively.\n",
    "Then, `PQC` will output a quantum circuit with $4L$ parameters for $L$ encoding layers, and $2L$ parameters for $L$ processing layers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# General 1-qubit gate\n",
    "# q0 = target qubit\n",
    "def Ugen(th, phi, lam, q0):\n",
    "    ugate = tq.gates.Rz(target=q0, angle=phi) + tq.gates.Ry(target=q0, angle=th) + tq.gates.Rz(target=q0, angle=lam)\n",
    "    return ugate\n",
    "\n",
    "def PQC(num_qubits, layers, arg, var_name):   \n",
    "    U = tq.QCircuit()\n",
    "    arg_tmp = [arg, arg]\n",
    "        \n",
    "    for l in range(layers):\n",
    "        # Layer single-qubit gates\n",
    "        for q in range(num_qubits):\n",
    "            theta = tq.Variable(name=\"{}_{}{}\".format(var_name, l, q))\n",
    "            phi = tq.Variable(name=\"{}2_{}{}\".format(var_name, l, q))\n",
    "            if arg_tmp[0] == 0 and arg_tmp[1] == 0:\n",
    "                U += Ugen(theta, phi, 0, q)  # for no encoding, reduce the total number of variables\n",
    "            else:\n",
    "                wth = tq.Variable(name=\"{}w_{}{}\".format(var_name, l, q))\n",
    "                wph = tq.Variable(name=\"{}2w_{}{}\".format(var_name, l, q))\n",
    "                U += Ugen(wth * arg_tmp[0] + theta, wph * arg_tmp[1] + phi, 0, q)\n",
    "        # Layer alternating CNOTs\n",
    "        ent0 = np.mod(l, 2)\n",
    "        for ent in range(ent0, num_qubits - 1, 2):\n",
    "            U += tq.gates.CNOT(control=ent, target=ent + 1)\n",
    "    return (U)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Main code: meta-VQE algorithm\n",
    "\n",
    "First, we define the main characteristics of the meta-VQE algorithm and the tests that we would like to run to compare its performace."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# PQC ansatz: same for encoding and processing layers\n",
    "ans_enc = PQC # ansatz variational circuit\n",
    "ans_var = PQC # ansatz encoding\n",
    "\n",
    "n_qub = 4 # qubits\n",
    "n_lay = [2,1] # layers [encoding, processing]\n",
    "\n",
    "# Hamiltonian argument limits\n",
    "arg_max = -1.1\n",
    "arg_min = 1.1\n",
    "lamXXZ = 0.75 # we set lambda, so the code only works with a single meta-parameter\n",
    "\n",
    "# Training and test points\n",
    "n_train = 20 \n",
    "n_test = 100 \n",
    "equispaced_train = True # if False, points are distributed at random\n",
    "equispaced_test = False\n",
    "\n",
    "# Optimizer options\n",
    "methods = 'BFGS'\n",
    "grad_methods = '2-point'\n",
    "backend = 'qulacs'\n",
    "lr = 0.01\n",
    "# make sure scipy version is >= 1.5\n",
    "mthd_opt = {'finite_diff_rel_step': 0.0001}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Meta-VQE\n",
    "\n",
    "As discussed in the main article, the cost function used to train the meta-VQE is the sum of the Hamiltonian expectation values w.r.t the parameterized quantum circuit initialized in the $|0\\rangle$ state:\n",
    "$$ \\mathcal{L}oss(\\vec{\\Phi},\\vec{\\Theta}) = \\sum_{i=1}^{M}\\langle\\psi_{i}\\lvert H(\\Delta_{i})|\\psi_{i}\\rangle, $$\n",
    "where\n",
    "$$ |\\psi_{i}\\rangle \\equiv |\\psi(\\Delta_{i},\\vec{\\Phi},\\vec{\\Theta})\\rangle = \\mathcal{U}(\\vec{\\Theta})\\mathcal{S}(\\Delta_{i},\\vec{\\Phi})|0\\rangle^{\\otimes n},$$\n",
    "and $\\Delta_{i}$ the Hamiltonian $\\Delta$ parameters from the training points, $\\mathcal{U}$ and $\\mathcal{S}$ the PQC corresponding to processing and encoding layers respectiverly (in these simulations, they have the same circuit structure, see above), and $\\vec{\\Phi},\\vec{\\Theta}$ are the optimization parameters aranged in a vector form.\n",
    "\n",
    "#### Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generate the training points\n",
    "if equispaced_train == True:\n",
    "    arg_train = [arg_min + i*(arg_max-arg_min)/(n_train-1) for i in range(n_train)]\n",
    "else:\n",
    "    arg_train = [random.uniform(arg_min, arg_max) for i in range(n_train)]\n",
    "    arg_train.sort()\n",
    "\n",
    "t0_metaVQE = time.time()\n",
    "# Construct the objective (cost function)\n",
    "Obj = tq.Objective()\n",
    "for i in range(n_train):\n",
    "    ham = HXXZ(n_qub, arg_train[i], lamXXZ)\n",
    "    # meta-VQE circuit: \n",
    "    # encoding variables share the prefix \"th_en\" and processing variables, the prefix \"th\"\n",
    "    total_U = ans_enc(n_qub, n_lay[0], arg_train[i], \"th_en\") + ans_var(n_qub, n_lay[1], 0, \"th\")\n",
    "\n",
    "    Obj += tq.ExpectationValue(H=ham, U=total_U)\n",
    "\n",
    "variables = Obj.extract_variables()\n",
    "variables = sorted(variables, key=lambda x: x.name)\n",
    "\n",
    "# Random initialization of variables\n",
    "th0 = {key: random.uniform(0, np.pi) for key in variables}\n",
    "\n",
    "initial_values = th0\n",
    "metaVQE = tq.minimize(objective=Obj, adaptive = True, lr=lr, method_options=mthd_opt, method=methods, gradient=grad_methods, samples=None,\n",
    "                      initial_values=initial_values, backend=backend, noise=None, device=None, silent=True)\n",
    "\n",
    "t1_metaVQE = time.time()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The variable `metaVQE` contains the result of the optimization, i.e. the final values of the loss function and optimization angles $\\vec{\\Phi}_{opt},\\vec{\\Theta}_{opt}$, together with optimization history. With these values, we can check what is the result of the training points and use them for the test points."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "t2_metaVQE = time.time()\n",
    "# Results training\n",
    "x_train = arg_train\n",
    "y_train_ex = []\n",
    "y_train_metaVQE = []\n",
    "error_train_metaVQE = []\n",
    "\n",
    "for i in range(n_train):\n",
    "    ham = HXXZ(n_qub, arg_train[i], lamXXZ)\n",
    "\n",
    "    # construct the corresponding PQC with the same variable names\n",
    "    total_U = ans_enc(n_qub, n_lay[0], arg_train[i], \"th_en\") + ans_var(n_qub, n_lay[1], 0, \"th\")\n",
    "\n",
    "    exp_val = tq.ExpectationValue(H=ham, U=total_U)\n",
    "    # Use the angles obtained in the training part\n",
    "    res = tq.simulate(exp_val, variables=metaVQE.angles) \n",
    "    # Exact result to compare\n",
    "    res_ex = exact(n_qub,arg_train[i], lamXXZ)\n",
    "\n",
    "    # print(arg_train[i], res_ex, res, abs(res-res_ex))\n",
    "\n",
    "    y_train_ex.append(res_ex)\n",
    "    y_train_metaVQE.append(res)\n",
    "    error_train_metaVQE.append(abs(res-res_ex))\n",
    "t3_metaVQE = time.time()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generate the testing points\n",
    "if equispaced_test == True:\n",
    "    arg_test = [arg_min + i*(arg_max-arg_min)/(n_test-1) for i in range(n_test)]\n",
    "    arg_test.sort()\n",
    "else:\n",
    "    arg_test = [random.uniform(arg_min, arg_max) for i in range(n_test)]\n",
    "    arg_test.sort()\n",
    "\n",
    "t4_metaVQE = time.time()\n",
    "x_test= arg_test\n",
    "y_test_ex = []\n",
    "y_test_metaVQE = []\n",
    "error_test_metaVQE = []\n",
    "\n",
    "Obj = tq.Objective()\n",
    "for i in range(n_test):\n",
    "    ham = HXXZ(n_qub, arg_test[i], lamXXZ)\n",
    "    # construct the corresponding PQC with the same variable names\n",
    "    total_U = ans_enc(n_qub, n_lay[0], arg_test[i], \"th_en\") + ans_var(n_qub, n_lay[1], 0, \"th\")\n",
    "\n",
    "    exp_val = tq.ExpectationValue(H=ham, U=total_U)\n",
    "    # Use the angles obtained in the training part\n",
    "    res = tq.simulate(exp_val, variables=metaVQE.angles)\n",
    "    # Exact result to compare\n",
    "    res_ex = exact(n_qub, arg_test[i], lamXXZ)\n",
    "\n",
    "    # print(arg_test[i], res_ex, res, abs(res - res_ex))\n",
    "\n",
    "    y_test_metaVQE.append(res)\n",
    "    y_test_ex.append(res_ex.real)\n",
    "    error_test_metaVQE.append(abs(res-res_ex.real))\n",
    "t5_metaVQE = time.time()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# PLOTS\n",
    "\n",
    "# g.s. energy\n",
    "plt.plot(x_test, y_test_ex, color=\"black\", ls=\":\", label=\"exact\")\n",
    "plt.plot(x_test, y_test_metaVQE,  ls=\"-\", label=\"metaVQE test\")\n",
    "plt.scatter(x_train, y_train_metaVQE, color=\"red\", marker=\"x\", label=\"metaVQE train\")\n",
    "plt.xlabel(\"Δ\")\n",
    "plt.ylabel('g.s. energy')\n",
    "plt.legend()\n",
    "plt.show()\n",
    "\n",
    "# Absolute error\n",
    "plt.plot(x_test, error_test_metaVQE, ls=\"-\", label=\"metaVQE test\")\n",
    "plt.scatter(x_train, error_train_metaVQE, marker=\"x\", color=\"red\", label=\"metaVQE train\")\n",
    "plt.xlabel(\"Δ\")\n",
    "plt.ylabel(\"Absolute error\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comparison with other algorithms\n",
    "\n",
    "#### Standard VQE\n",
    "\n",
    "The first comparison test correponds with the well-known VQE algorithm. The standard VQE optimizes the values of the variables of the PQC for each Hamiltonian, i.e. for each value of $\\Delta$. Then, in contrast with meta-VQE, we have to run individual optimizations for each Hamiltonian point instead of a single big optimization. \n",
    "\n",
    "The other main difference between VQE and meta-VQE is the encoding part of the circuit. Standard VQE algorithms do not encode the variables of the Hamiltonian into the PQC. Then, to compare with the above meta-VQE results, we fix the circuit depth, i.e. the total number of layers is the same, but all single-qubit rotations contain only two optimization variables (as if all layers were processing layers).\n",
    "\n",
    "Due to the computational cost of running individual optimization for each value of $\\Delta$, we compare meta-VQE and VQE algorithms using the equispaced training points generated for meta-VQE."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "t0_VQE = time.time()\n",
    "\n",
    "y_stVQE = []\n",
    "error_stVQE = []\n",
    "\n",
    "for i in range(n_train):\n",
    "    ham = HXXZ(n_qub, arg_train[i], lamXXZ)\n",
    "\n",
    "    # VQE circuit layers same as meta-VQE layers (encoding + variational parts)\n",
    "    total_U = ans_var(n_qub, n_lay[0]+n_lay[1], 0, \"th\")\n",
    "\n",
    "    Obj = tq.ExpectationValue(H=ham, U=total_U)\n",
    "\n",
    "    variables = Obj.extract_variables()\n",
    "    variables = sorted(variables, key=lambda x: x.name)\n",
    "\n",
    "    # Random initialization of variables\n",
    "    # new initialization because the circuit is different (no encoding part)\n",
    "    th0_bis = {key: random.uniform(0, np.pi) for key in variables}\n",
    "\n",
    "    initial_values = th0_bis\n",
    "    standardVQE = tq.minimize(objective=Obj, adaptive = True, lr=lr, method_options=mthd_opt, method=methods, gradient=grad_methods, samples=None,\n",
    "                              initial_values=initial_values, backend=backend, noise=None,\n",
    "                              device=None, silent=True)\n",
    "    res = standardVQE.energy\n",
    "    # res_ex = Exact results same as meta-VQE training points\n",
    "\n",
    "    # print(arg_train[i], y_train_ex[i], res, abs(res - y_train_ex[i]))\n",
    "\n",
    "    y_stVQE.append(res)\n",
    "    error_stVQE.append(abs(res-y_train_ex[i]))\n",
    "    \n",
    "t1_VQE = time.time()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Globally-averaged VQE (GA-VQE)\n",
    "\n",
    "To check the power of the encoding strategy of the meta-VQE, we run a meta-VQE-like algorithm without encoding the Hamiltonian variables. We call this algorithm globally-averaged VQE, since it has the same PQC strucutre of a standard VQE but the optimization is done globally, by using the meta-VQE cost function defined above.\n",
    "\n",
    "We use the same points used in the meta-VQE to train and test the GA-VQE."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "t0_GAVQE = time.time()\n",
    "\n",
    "Obj = tq.Objective()\n",
    "for i in range(n_train):\n",
    "    ham = HXXZ(n_qub, arg_train[i], lamXXZ)\n",
    "\n",
    "    # same number of layers as VQE and meta-VQE (encoding + variational parts)\n",
    "    total_U = ans_var(n_qub, n_lay[0] + n_lay[1], 0, \"th\")\n",
    "\n",
    "    Obj += tq.ExpectationValue(H=ham, U=total_U)\n",
    "\n",
    "# same variables as a starndard VQE, same random initiaization\n",
    "initial_values = th0_bis\n",
    "GA_VQE = tq.minimize(objective=Obj, adaptive = True, lr=lr, method_options=mthd_opt, method=methods, gradient=grad_methods, samples=None,\n",
    "                            initial_values=initial_values, backend=backend, noise=None,\n",
    "                            device=None, silent=True)\n",
    "\n",
    "y_test_GAVQE = []\n",
    "error_test_GAVQE = []\n",
    "\n",
    "for i in range(n_test):\n",
    "    ham = HXXZ(n_qub, arg_test[i], lamXXZ)\n",
    "\n",
    "    # same number of layers as VQE and meta-VQE (encoding + variational parts)\n",
    "    total_U = ans_var(n_qub, n_lay[0] + n_lay[1], 0, \"th\")\n",
    "\n",
    "    exp_val = tq.ExpectationValue(H=ham, U=total_U)\n",
    "    res = tq.simulate(exp_val, variables=GA_VQE.angles)\n",
    "    # res_ex = same as meta-VQE test\n",
    "\n",
    "    # print(arg_test[i], y_test_ex[i], res, abs(res-y_test_ex[i]))\n",
    "\n",
    "    y_test_GAVQE.append(res)\n",
    "    error_test_GAVQE.append(abs(res-y_test_ex[i]))\n",
    "    \n",
    "t1_GAVQE = time.time()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### VQE with meta-VQE initialization (opt-meta-VQE)\n",
    "\n",
    "Another potential advantage of running a meta-VQE algorithm is using the optimized variables of the later as initialization for the former. It is well known the barren plateau problem of PQC: if the minimization algorithm starts at a random point, both the gradient and variance of optimization variables tend to zero exponentially, leading a local minima result. There are several proposals to circunvent this problem. Ours is to start in a region close to the ground state solution by using the result of a meta-VQE as initialization point for a standard VQE (opt-meta-VQE).\n",
    "\n",
    "Since the standard VQE do not contain encoding layers (with more optimization variables than the processing layers), we need to use a meta-VQE-like circuit to run the opt-meta-VQE (which uses the variables of the meta-VQE as starting point for the optimization). The use of encoding layes for a standard VQE had no sense, since the variables are initialized at random and, therefore, the two variables per rotational gate of the encoding layers can be redifined as a single variable. However, in this case, we are not starting at random but in a particular point suggested by the meta-VQE solution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "t0_optmetaVQE = time.time()\n",
    "\n",
    "y_optmetaVQE = []\n",
    "error_optmetaVQE = []\n",
    "\n",
    "for i in range(n_train):\n",
    "    ham = HXXZ(n_qub, arg_train[i], lamXXZ)\n",
    "\n",
    "    # VQE with encoding layers (a meta-VQE PQC)\n",
    "    total_U = ans_enc(n_qub, n_lay[0], arg_train[i], \"th_en\") + ans_var(n_qub, n_lay[1], 0, \"th\")\n",
    "\n",
    "    Obj = tq.ExpectationValue(H=ham, U=total_U)\n",
    "\n",
    "    # Initial values are the angles obtained after running the meta-VQE\n",
    "    initial_values = metaVQE.angles\n",
    "\n",
    "    optmetaVQE = tq.minimize(objective=Obj, adaptive = True, lr=lr, method_options=mthd_opt, method=methods, gradient=grad_methods,\n",
    "                                           samples=None,\n",
    "                                           initial_values=initial_values, backend=backend, noise=None, device=None,\n",
    "                                           silent=True)\n",
    "    res = optmetaVQE.energy\n",
    "    # res_ex: Exact results same as meta-VQE training points\n",
    "\n",
    "    # print(arg_train[i], y_train_ex[i], res, abs(res - y_train_ex[i]))\n",
    "\n",
    "    y_optmetaVQE.append(res)\n",
    "    error_optmetaVQE.append(abs(res - y_train_ex[i]))\n",
    "    \n",
    "t1_optmetaVQE = time.time()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### VQE with GA-VQE initialization (opt-GA-VQE)\n",
    "\n",
    "Finally, last test consist on using the result of the GA-VQE as the starting point for a standard VQE, similarly to the previous test. This time, the number of variables and the PQC is the same as the standard VQE (with no encoding layers)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "t0_optGAVQE = time.time()\n",
    "\n",
    "y_optGAVQE = []\n",
    "error_optGAVQE= []\n",
    "\n",
    "for i in range(n_train):\n",
    "    ham = HXXZ(n_qub, arg_train[i], lamXXZ)\n",
    "        \n",
    "    # VQE number circuit layers same as meta-VQE layers (encoding + variational parts)\n",
    "    total_U = ans_var(n_qub, n_lay[0] + n_lay[1], 0, \"th\")\n",
    "\n",
    "    Obj = tq.ExpectationValue(H=ham, U=total_U)\n",
    "\n",
    "    # Initial values are the ones obtained in the GA-VQE optimization\n",
    "    initial_values = GA_VQE.angles\n",
    "\n",
    "    optGAVQE = tq.minimize(objective=Obj, adaptive = True, lr=lr, method_options=mthd_opt, method=methods, gradient=grad_methods,\n",
    "                                                 samples=None,\n",
    "                                                 initial_values=initial_values, backend=backend, noise=None,\n",
    "                                                 device=None, silent=True)\n",
    "    res = optGAVQE.energy\n",
    "    # res_ex: Exact results same as meta-VQE training points\n",
    "\n",
    "    #print(arg_train[i], y_train_ex[i], res, abs(res - y_train_ex[i]))\n",
    "\n",
    "    y_optGAVQE.append(res)\n",
    "    error_optGAVQE.append(abs(res - y_train_ex[i]))\n",
    "    \n",
    "t1_optGAVQE = time.time()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(x_test, y_test_ex, color=\"black\", ls=\":\", label=\"exact\")\n",
    "plt.plot(x_test, y_test_metaVQE,  ls=\"-\", label=\"metaVQE test\")\n",
    "plt.scatter(x_train, y_train_metaVQE, color=\"red\", marker=\"x\", label=\"metaVQE train\")\n",
    "plt.plot(x_train, y_stVQE,  marker=\".\", label=\"VQE\")\n",
    "plt.plot(x_test, y_test_GAVQE,  ls=\"--\", label=\"GA-VQE\")\n",
    "plt.plot(x_train, y_optmetaVQE, marker=\"*\", label=\"opt-meta-VQE\")\n",
    "plt.plot(x_train, y_optGAVQE, marker=\"v\", label=\"opt-GA-VQE\")\n",
    "\n",
    "plt.xlabel(\"Δ\")\n",
    "plt.ylabel('g.s. energy')\n",
    "plt.legend()\n",
    "\n",
    "plt.show()\n",
    "\n",
    "# Absolute error\n",
    "\n",
    "plt.plot(x_test, error_test_metaVQE, ls=\"-\", label=\"metaVQE test\")\n",
    "plt.scatter(x_train, error_train_metaVQE, marker=\"x\", color=\"red\", label=\"metaVQE train\")\n",
    "plt.plot(x_train, error_stVQE, marker=\".\", label=\"VQE\")\n",
    "plt.plot(x_test, error_test_GAVQE, ls=\"--\", label=\"GA-VQE\")\n",
    "plt.plot(x_train, error_optmetaVQE, marker=\"*\", label=\"opt-meta-VQE\")\n",
    "plt.plot(x_train, error_optGAVQE, marker=\"v\", label=\"opt-GA-VQE\")\n",
    "\n",
    "plt.xlabel(\"Δ\")\n",
    "plt.ylabel(\"Absolute error\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:tqenv2] *",
   "language": "python",
   "name": "conda-env-tqenv2-py"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}