├── .ipynb_checkpoints ├── Fitting-checkpoint.ipynb ├── Meta-VQE-checkpoint.ipynb ├── Molecular-Meta-VQE-checkpoint.ipynb ├── QFit-checkpoint.ipynb └── SingleQubitClassifier-checkpoint.ipynb ├── Meta-VQE.ipynb ├── Molecular-Meta-VQE.ipynb ├── QFit.ipynb ├── README.md └── SingleQubitClassifier.ipynb /.ipynb_checkpoints/Molecular-Meta-VQE-checkpoint.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Non-Linear Molecular Meta-VQE

\n", 8 | "_______________________________________________________\n", 9 | "\n", 10 | "_Authors:_ Alba Cervera-Lierta, Jakob S. Kottmann, Alán Aspuru-Guzik.\n", 11 | "\n", 12 | "This notebook presents a demo code illustrate a non-linear molecular meta-VQE as introduced in the article \"The Meta-Variational Quantum Eigensolver (Meta-VQE): Learning energy profiles of parameterized Hamiltonians for quantum simulation\" (http://arxiv.org/abs/2009.13545).\n", 13 | "\n", 14 | "We will explicitly illustrate how to construct a non-linear meta-VQE for molecular systems. \n", 15 | "In this Notebook we will use the simplest system available, the Hydrogen molecule in a minimal representation. \n", 16 | "The molecular coordinates, or the basis-set can however be replaced (as long as there is just a single meta-parameter $R$ in the coordinates), but note that the training will take substantially longer, depending on the system/basis you chose, and a jupyter notebook is probably not the best environment anymore.\n", 17 | "\n", 18 | "In order to run the notebook you need to have `tequila` installed. \n", 19 | "Just follow the intructions from the [AAG github repository](https://github.com/aspuru-guzik-group/tequila) and let us know if you experience any troubles. Feel also free to check out the `tequila` [tutorials](https://github.com/aspuru-guzik-group/tequila/tree/master/tutorials). For this notebook we recommend [basic usage](https://github.com/aspuru-guzik-group/tequila/blob/master/tutorials/BasicUsage.ipynb) and [basic chemistry](https://github.com/aspuru-guzik-group/tequila/blob/master/tutorials/Chemistry.ipynb).\n", 20 | "\n", 21 | "We start by defining our non-linear encoder. As in the paper we will use a set of floating Gaussians to approximate our unknown non-linear function. Each parameter of the VQE is then encoded, depending on the meta variable $R$ (in this example the bond distance of H$_2$; in the paper the intermolecular distance of H$_4$), as\n", 22 | "$$\n", 23 | "\\theta\\left(R\\right) = \\sum_n \\alpha_n \\exp\\left( -\\beta_n (\\gamma_n - R)^2\\right) + \\delta.\n", 24 | "$$\n", 25 | "\n", 26 | "In the following cell, we define this encoder as abstract class can produce `tequila` objectives which will be used as parameters for quantum circuits later.\n", 27 | "\n", 28 | "The `DummyEncoder` class just gives back the original variable, we will use it to test the meta-VQE later. \n", 29 | "In the same way the `evaluate` function will later be used to initialize the $\\theta$ parameters to test the meta-VQE after training.\n", 30 | "\n", 31 | "If you have any questions left, feel free to contact us." 32 | ] 33 | }, 34 | { 35 | "cell_type": "code", 36 | "execution_count": 1, 37 | "metadata": {}, 38 | "outputs": [], 39 | "source": [ 40 | "# tested with tq git revision: ab252adc4090465ff47f182de32d69b84d7fc13f\n", 41 | "import tequila as tq\n", 42 | "import numpy" 43 | ] 44 | }, 45 | { 46 | "cell_type": "code", 47 | "execution_count": 2, 48 | "metadata": {}, 49 | "outputs": [], 50 | "source": [ 51 | "class DummyEncoder:\n", 52 | " \"\"\"\n", 53 | " No encoding\n", 54 | " \"\"\"\n", 55 | " def __call__(self, variable, *args, **kwargs):\n", 56 | " return variable\n", 57 | " \n", 58 | "class GaussianEncoder:\n", 59 | " \"\"\"\n", 60 | " Represent an unknown linear function by n floating Gaussians \n", 61 | " \"\"\"\n", 62 | " def __init__(self, n):\n", 63 | " self._n = n\n", 64 | "\n", 65 | " def __call__(self, variable, R):\n", 66 | " # this allows us to just pass names as parameters\n", 67 | " variable = tq.assign_variable(variable)\n", 68 | " \n", 69 | " # here we create the non-linear encoded parameter\n", 70 | " # as described in the paper\n", 71 | " # as abstract tequila objective\n", 72 | " mapped = tq.Variable((\"delta\", variable))\n", 73 | " for n in range(self._n):\n", 74 | " a = tq.Variable((\"alpha\", variable, n))\n", 75 | " b = tq.Variable((\"beta\", variable, n))\n", 76 | " c = tq.Variable((\"gamma\", variable, n))\n", 77 | " mapped += a * ((-(b * (c - R) ** 2)).apply(tq.numpy.exp))\n", 78 | " return mapped\n", 79 | " \n", 80 | " def evaluate(self, variable, R, trained_variables):\n", 81 | " # evaluates a specficic variale at point R\n", 82 | " # according to alpha*exp(-beta*(gamma - variable)**2) + delta\n", 83 | " # needs the trained variables which are (\"alpha\", variable, n)\n", 84 | " # and similar for the other meta parameters\n", 85 | " result = 0.0\n", 86 | " for n in range(self._n):\n", 87 | " a = trained_variables[(\"alpha\", variable, n)]\n", 88 | " b = trained_variables[(\"beta\", variable, n)]\n", 89 | " c = trained_variables[(\"gamma\", variable, n)]\n", 90 | " d = trained_variables[(\"delta\", variable)]\n", 91 | " result += a*numpy.exp(-b*(c-R)**2) + d\n", 92 | " return result" 93 | ] 94 | }, 95 | { 96 | "cell_type": "markdown", 97 | "metadata": {}, 98 | "source": [ 99 | "## The VQE Ansatz\n", 100 | "\n", 101 | "Now its time to define the ansatz for our molecular VQE. \n", 102 | "As in the paper, we will use the [UpCCGSD](https://pubs.acs.org/doi/10.1021/acs.jctc.8b01004) ansatz.\n", 103 | "\n", 104 | "The quantum circuit for this ansatz has the form \n", 105 | "$$\n", 106 | "U(\\boldsymbol{\\theta}) = \\left(\\prod_k e^{-i\\frac{\\theta_k}{2} G_k}\\right) U_\\text{ref} \n", 107 | "$$\n", 108 | "where the generators $G_k$ are qubit encoded products of fermionic creation and anihialtion operators; In this case, single excitations and pair-restricted double excitations of the form\n", 109 | "$$\n", 110 | "G_{pq} = i(a_p^\\dagger a_q - a^\\dagger_q a_p)\n", 111 | "$$\n", 112 | "and\n", 113 | "$$\n", 114 | "G_{pqrs} = i(a_p^\\dagger a_q a_r^\\dagger a_s - h.c.).\n", 115 | "$$\n", 116 | "The pair-restriction in the doubles requires the spin orbitals $p,q$ and $r,s$ to have the same spatial part. This is enforced in the code block below by iterating over spatial indices and generating $p,q$ and $r,s$ from them (`tequila` will enumerate spin-up with even and spin-down with off numbers).\n", 117 | "\n", 118 | "The qubit encoded generators are sums of tensor-products of Pauli matrices. Their explicit form depends on the qubit encoding chosen below (the default here is `jordan_wigner`). If you want to know the explicit form of some generators, just construct them as illustrated below, and then print them out. Note that the qubit encoding is set over the `transformation` key when the molecule object is created (see cells further below).\n", 119 | "\n", 120 | "The $U_\\text{ref}$ part of the circuit creates the Hartree-Fock reference. The explicit form also depends on the chosen qubit encoding and the `tequila` molecule object handles the correct initialization. In our specfic H$_2$\\STO-3G example below in `jordan_wigner` representation, the $U_\\text{ref}$ circuit consists of two $X$ gates on qubits 0 and 1 (the spin-up and spin-down encoded occupied HF orbital).\n", 121 | "\n", 122 | "Note that for the Hydrogen system we can neglect the singles for point-group symmetry reasons, and for the same reasons will only end up with one pair-ecitation for the doubles anyway. \n", 123 | "The code-block below will however generate the ansatz independent of the molecular that is passed to it. \n", 124 | "Note that the encoder is also passed to the function, so in principle you can also use other encoders as the ones defined above; They just need to have a call operator defined which takes the name of the variable to encode and the meta paramerer $R$." 125 | ] 126 | }, 127 | { 128 | "cell_type": "code", 129 | "execution_count": 3, 130 | "metadata": {}, 131 | "outputs": [], 132 | "source": [ 133 | "def encoded_upccgsd(molecule, encoder, R, layers=1, include_singles=True):\n", 134 | " U = molecule.prepare_reference()\n", 135 | " for layer in range(layers):\n", 136 | " for i in range(molecule.n_orbitals):\n", 137 | " for a in range(i+1,molecule.n_orbitals):\n", 138 | " # First the pair-restricted doubles\n", 139 | " # create the encoded angle objective\n", 140 | " angle = encoder(\"D_{}_{}_{}\".format(layer, i, a), R)\n", 141 | " G = molecule.make_excitation_generator(indices=[(2*i,2*a),(2*i+1,2*a+1)])\n", 142 | " U += tq.gates.Trotterized(generators=[G], angles=[angle], steps=1)\n", 143 | " if not include_singles:\n", 144 | " continue\n", 145 | " # now the same for the singles; we will use the same parameter\n", 146 | " # for spin-up and spin-down singles to enforce singlet to enforce singlet symmetry\n", 147 | " angle = encoder(\"S_{}_{}_{}\".format(layer, i, a), R)\n", 148 | " G1 = molecule.make_excitation_generator(indices=[(2*i,2*a)])\n", 149 | " G2 = molecule.make_excitation_generator(indices=[(2*i+1,2*a+1)])\n", 150 | " U += tq.gates.Trotterized(generators=[G1,G2], angles=[angle,angle], steps=1)\n", 151 | " return U" 152 | ] 153 | }, 154 | { 155 | "cell_type": "markdown", 156 | "metadata": {}, 157 | "source": [ 158 | "## Construction and Training of the meta-VQE \n", 159 | "\n", 160 | "Now we will construct our meta-VQE objective by summing up expectationvalues with meta parameters defined by a set of training points. \n", 161 | "\n", 162 | "After the `tequila` objective is created we minimize it with the `BFGS` optimizer of the `scipy` package. \n", 163 | "If you want to try another optimizer, see the tequila [tutorials](https://github.com/aspuru-guzik-group/tequila/blob/master/tutorials/Optimizer_Tutorial.ipynb) or type `tq.show_available_optimizers()` to see which optimizers are available on your system." 164 | ] 165 | }, 166 | { 167 | "cell_type": "code", 168 | "execution_count": 4, 169 | "metadata": {}, 170 | "outputs": [ 171 | { 172 | "name": "stdout", 173 | "output_type": "stream", 174 | "text": [ 175 | "initial values are:\n", 176 | " {('alpha', D_0_0_1, 0): 0.0, ('delta', D_0_0_1): 0.0, ('gamma', D_0_0_1, 0): 1.0, ('beta', D_0_0_1, 0): 1.0}\n", 177 | "Optimizer: \n", 178 | "backend : qulacs\n", 179 | "device : None\n", 180 | "samples : None\n", 181 | "save_history : True\n", 182 | "noise : None\n", 183 | "\n", 184 | "Method : BFGS\n", 185 | "Objective : 5 expectationvalues\n", 186 | "grad instr : 2-point\n", 187 | "gradient : scipy numerical 2-point\n", 188 | "hessian : scipy numerical None\n", 189 | "\n", 190 | "active variables : 4\n", 191 | "\n", 192 | "Optimization terminated successfully.\n", 193 | " Current function value: -1.010502\n", 194 | " Iterations: 13\n", 195 | " Function evaluations: 110\n", 196 | " Gradient evaluations: 22\n", 197 | "Finished Training of Meta VQE\n", 198 | "optimized meta-variables are:\n", 199 | " ('alpha', D_0_0_1, 0) : -1.3507766463040127\n", 200 | "('delta', D_0_0_1) : 1.5022768577876158\n", 201 | "('gamma', D_0_0_1, 0) : 0.6887929726422215\n", 202 | "('beta', D_0_0_1, 0) : 0.8901106480850393\n", 203 | "\n" 204 | ] 205 | } 206 | ], 207 | "source": [ 208 | "# define the encoder\n", 209 | "encoder = GaussianEncoder(n=1)\n", 210 | "\n", 211 | "# define details on the VQE ansatz\n", 212 | "layers = 1\n", 213 | "include_singles = False\n", 214 | "transformation = \"jordan_wigner\"\n", 215 | "geometry = \"H 0.0 0.0 0.0\\nH 0.0 0.0 {R}\" # gan also give path to an xyz file\n", 216 | "basis_set = \"sto-3g\"\n", 217 | "\n", 218 | "# define the training points\n", 219 | "training_points = [0.5, 0.7, 1.5, 3.0, 5.0]\n", 220 | "\n", 221 | "# define the test points\n", 222 | "start = 0.3\n", 223 | "end = 7.0\n", 224 | "steps = 25\n", 225 | "test_points = [start + step/steps*(end-start) for step in range(steps)]\n", 226 | "\n", 227 | "# Details on the used optimizer:\n", 228 | "optimizer_arguments = {}\n", 229 | "# see tq.show_available_optimizers() for other options\n", 230 | "optimizer_arguments[\"method\"] = \"bfgs\"\n", 231 | "# increase to see more output in the optimization\n", 232 | "optimizer_arguments[\"print_level\"] = 1\n", 233 | "optimizer_arguments[\"gradient\"] = \"2-point\"\n", 234 | "# eps for scipy < 1.5, and finite_diff_rel_step for scipy > 1.5\n", 235 | "optimizer_arguments[\"method_options\"] = {\"finite_diff_rel_step\":1.e-5, \"eps\":1.e-5, \"gtol\":1.e-5}\n", 236 | "\n", 237 | "\n", 238 | "#construct the tequila objective by accumulating expectation values of training points\n", 239 | "objective = 0.0\n", 240 | "for R in training_points:\n", 241 | " molecule = tq.chemistry.Molecule(geometry=geometry.format(R=R), basis_set=basis_set, transformation=transformation)\n", 242 | " H = molecule.make_hamiltonian()\n", 243 | " U = encoded_upccgsd(molecule, encoder, R, layers, include_singles)\n", 244 | " \n", 245 | " E = tq.ExpectationValue(H=H, U=U)\n", 246 | " objective += E\n", 247 | "\n", 248 | "objective = 1.0/len(training_points)*objective\n", 249 | " \n", 250 | "# initialize in a way that the encoded angles start with zero\n", 251 | "# initialize beta and gamma as 1.0, since they are width and shift of the Gaussians\n", 252 | "initial_values = {k:(1.0 if \"beta\" in k.name[0] or \"gamma\" in k.name[0] else 0.0) for k in objective.extract_variables()}\n", 253 | "\n", 254 | "# if we have more than one floating Gaussian, we should not initialize the shifts (gamma) to the same values\n", 255 | "# otherwise the optimizer can get confused\n", 256 | "if encoder._n > 1:\n", 257 | " initial_values = {k:(numpy.random.uniform(training_points[0], training_points[-1], 1)[0] if \"gamma\" in k.name[0] else initial_values[k]) for k in objective.extract_variables()}\n", 258 | "\n", 259 | "print(\"initial values are:\\n\", initial_values)\n", 260 | " \n", 261 | "# minimize the objective formed from the training points\n", 262 | "trained = tq.minimize(objective=objective, initial_values=initial_values, **optimizer_arguments)\n", 263 | "\n", 264 | "print(\"Finished Training of Meta VQE\")\n", 265 | "print(\"optimized meta-variables are:\\n\", trained.variables)\n", 266 | "\n" 267 | ] 268 | }, 269 | { 270 | "cell_type": "markdown", 271 | "metadata": {}, 272 | "source": [ 273 | "## Testing the performance of the meta-VQE\n", 274 | "\n", 275 | "Here we gonna test the performance of the meta-VQE by computing the expectation values of different points with the parameters of the quantum circuit initialized by the trained meta-VQE. For this we will need the `evaluate` function of the encoder. Furthermore we will compute the `fci` energy of each test point, and optimize the individual points with a standard VQE initialized with the meta-VQE values (opt-meta-VQE). \n", 276 | "See the paper for further details." 277 | ] 278 | }, 279 | { 280 | "cell_type": "code", 281 | "execution_count": 5, 282 | "metadata": {}, 283 | "outputs": [ 284 | { 285 | "name": "stdout", 286 | "output_type": "stream", 287 | "text": [ 288 | "processing test point +0.3000\n", 289 | "processing test point +0.5680\n", 290 | "processing test point +0.8360\n", 291 | "processing test point +1.1040\n", 292 | "processing test point +1.3720\n", 293 | "processing test point +1.6400\n", 294 | "processing test point +1.9080\n", 295 | "processing test point +2.1760\n", 296 | "processing test point +2.4440\n", 297 | "processing test point +2.7120\n", 298 | "processing test point +2.9800\n", 299 | "processing test point +3.2480\n", 300 | "processing test point +3.5160\n", 301 | "processing test point +3.7840\n", 302 | "processing test point +4.0520\n", 303 | "processing test point +4.3200\n", 304 | "processing test point +4.5880\n", 305 | "processing test point +4.8560\n", 306 | "processing test point +5.1240\n", 307 | "processing test point +5.3920\n", 308 | "processing test point +5.6600\n", 309 | "processing test point +5.9280\n", 310 | "processing test point +6.1960\n", 311 | "processing test point +6.4640\n", 312 | "processing test point +6.7320\n" 313 | ] 314 | } 315 | ], 316 | "source": [ 317 | "fci = {}\n", 318 | "meta = {}\n", 319 | "meta_angles = {}\n", 320 | "meta_opt = {}\n", 321 | "vqe = {}\n", 322 | "# we are using this to be able to use the same codeblocks\n", 323 | "dummy = DummyEncoder()\n", 324 | "for R in test_points:\n", 325 | " print(\"processing test point {:+2.4f}\".format(R))\n", 326 | " molecule = tq.chemistry.Molecule(geometry=geometry.format(R=R), basis_set=basis_set, transformation=transformation)\n", 327 | " H = molecule.make_hamiltonian()\n", 328 | " U = encoded_upccgsd(molecule, dummy, R, layers, include_singles)\n", 329 | " E = tq.ExpectationValue(H=H, U=U)\n", 330 | " \n", 331 | " # evaluate regular VQE with meta VQE parameters\n", 332 | " values = {k:encoder.evaluate(variable=k, R=R, trained_variables=trained.variables) for k in E.extract_variables()}\n", 333 | " energy = tq.simulate(E, variables=values)\n", 334 | " meta[R] = energy\n", 335 | " meta_angles[R] = values\n", 336 | " \n", 337 | " # optimize from meta VQE starting point\n", 338 | " result = tq.minimize(objective=E, initial_values=values, silent=True, **optimizer_arguments)\n", 339 | " meta_opt[R] = result.energy\n", 340 | " \n", 341 | " # try fci (you will need psi4 for this)\n", 342 | " try:\n", 343 | " fci[R] = molecule.compute_energy(\"fci\")\n", 344 | " except:\n", 345 | " if molecule.n_orbitals < 5:\n", 346 | " fci[R] = numpy.linalg.eigvalsh(H.to_matrix())[0]\n", 347 | " else:\n", 348 | " print(\"skipping fci for point \", R)\n" 349 | ] 350 | }, 351 | { 352 | "cell_type": "markdown", 353 | "metadata": {}, 354 | "source": [ 355 | "The collected data of the test above is plotted here. \n", 356 | "Since we only have one parameter in our simple guinny pig system here, we will also plot the quantum circuit's parameter with respect to the meta parameter $R$. \n", 357 | "If you have changed the molecule or the basis_set above, you might need to adapt the plot for the parameter in order to see the parameter you are interested in.\n", 358 | "\n", 359 | "For our guinny-pig system and the default settings in this notebook you see that the meta-VQE predicts the whole PES accurately with exception of the point at very close distance. The reason can be seen in the plot of the parameter. For this specific system and this specfic VQE ansatz, the ideal parameter will have a sigmoidal dependence on the meta parameter $R$ and the single floating Gaussian is not able to perfectly adapt to it. As explained in the paper: Chosing floating Gaussians was a pragmatic choice since they are fairly good approximators for generalized functions.\n", 360 | "\n", 361 | "\n", 362 | "If you are interested you can try to change the encoder above, to a sigmoidal function, then you will be able to fit this test system almost perfectly. Another way to improve is to increase the number of floating Gaussians. \n", 363 | "Feel free to play around with it!" 364 | ] 365 | }, 366 | { 367 | "cell_type": "code", 368 | "execution_count": 6, 369 | "metadata": {}, 370 | "outputs": [ 371 | { 372 | "data": { 373 | "image/png": "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\n", 374 | "text/plain": [ 375 | "