From c8513f108f8d7761348367b1b9cc2ab1639f3726 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Thu, 25 Jan 2024 14:17:35 +0800 Subject: [PATCH 01/22] dbi scheduling first commit: added feature 3 options of scheduling methods. --- examples/dbi/dbi_scheduling.ipynb | 275 ++++++++++++++++++++++++++ src/qibo/models/dbi/double_bracket.py | 139 ++++++++++++- 2 files changed, 411 insertions(+), 3 deletions(-) create mode 100644 examples/dbi/dbi_scheduling.ipynb diff --git a/examples/dbi/dbi_scheduling.ipynb b/examples/dbi/dbi_scheduling.ipynb new file mode 100644 index 0000000000..066d56640d --- /dev/null +++ b/examples/dbi/dbi_scheduling.ipynb @@ -0,0 +1,275 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Double-bracket Iteration Scheduling Strategies\n", + "\n", + "This notebook presents the different strategies for scheduling the step durations for the double-bracket iteration algorithm and their resepctive accuracies." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Import the dependencies" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from copy import deepcopy\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from qibo import hamiltonians, set_backend\n", + "from qibo.models.dbi.double_bracket import DoubleBracketGeneratorType, DoubleBracketScheduling, DoubleBracketIteration\n", + "from qibo.models.dbi.utils import *" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Canonical\n", + "Set up the basic test case with the transverse field ising model hamiltonian and the canonical bracket as the generator." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Hamiltonian\n", + "set_backend(\"qibojit\", \"numba\")\n", + "\n", + "# hamiltonian parameters\n", + "nqubits = 5\n", + "h = 3\n", + "\n", + "# define the hamiltonian\n", + "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=h)\n", + "\n", + "# initialize class\n", + "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.canonical)\n", + "print(\"Initial off diagonal norm\", dbi.off_diagonal_norm)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We first generate the relationship between the step duration and the off-diagoanl norm (loss function) for the first step of the iteration." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# generate data for plotting sigma decrease of the first step\n", + "s_space = np.linspace(1e-5, 0.6, 100)\n", + "off_diagonal_norm_diff = []\n", + "for s in s_space:\n", + " dbi_eval = deepcopy(dbi)\n", + " dbi_eval(s)\n", + " off_diagonal_norm_diff.append(dbi_eval.off_diagonal_norm - dbi.off_diagonal_norm)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The default scheduling strategy is grid search: `DoubleBracketScheduling.use_grid_serach`. This strategy specifies a list of step durations to test one by one and finds the one that maximizes the cost function (off-digonal norm of Hamiltonian)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# grid_search\n", + "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.use_grid_search)\n", + "print('grid_search step:', step_grid)\n", + "# hyperopt\n", + "step_hyperopt = dbi.choose_step(scheduling=DoubleBracketScheduling.use_hyperopt, max_evals=100, step_max=0.6)\n", + "print('hyperopt_search step:', step_hyperopt)\n", + "# polynomial expansion\n", + "step_poly = dbi.choose_step(scheduling=DoubleBracketScheduling.use_polynomial_approximation, n=5)\n", + "print('polynomial_approximation step:', step_poly)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Plot the results\n", + "plt.plot(s_space, off_diagonal_norm_diff)\n", + "plt.axvline(x=step_grid, color='r', linestyle='-',label='grid_search')\n", + "plt.axvline(x=step_hyperopt, color='g', linestyle='--',label='hyperopt')\n", + "plt.axvline(x=step_poly, color='m', linestyle='-.',label='polynomial')\n", + "plt.ylabel(r'$||\\sigma(H_0)||-\\sigma(H_k)||$')\n", + "plt.xlabel('s')\n", + "plt.title('hyperopt first step')\n", + "plt.legend()\n", + "print('The minimum for cost function in the tested range is:', step_grid)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Specified diagonal operator\n", + "\n", + "While for the cannonical case, all the scheduling methods are accurate, it is important to realize that the global minimum of the loss function is not always so obvious. It is thus necessary to show whether the 3 converges to an agreeable step duration using different iteration generators, such as the Pauli 'ZZ..Z' operator and 'ZZ..I' operator." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Generate the digaonal operators\n", + "Z_op = SymbolicHamiltonian(str_to_symbolic(\"Z\"*nqubits)).dense.matrix\n", + "ZI_op = SymbolicHamiltonian(str_to_symbolic(\"Z\"*(nqubits-1)+\"I\")).dense.matrix" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator)\n", + "d = Z_op\n", + "# generate data for plotting sigma decrease of the first step\n", + "s_space = np.linspace(1e-5, 0.6, 100)\n", + "off_diagonal_norm_diff = []\n", + "for s in s_space:\n", + " dbi_eval = deepcopy(dbi)\n", + " dbi_eval(s,d=d)\n", + " off_diagonal_norm_diff.append(dbi_eval.off_diagonal_norm - dbi.off_diagonal_norm)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# grid_search\n", + "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.use_grid_search, step_max=0.6, d=d)\n", + "print('grid_search step:', step_grid)\n", + "# hyperopt\n", + "step_hyperopt = dbi.choose_step(scheduling=DoubleBracketScheduling.use_hyperopt, d=d, max_evals=100, step_max=0.6)\n", + "print('hyperopt_search step:', step_hyperopt)\n", + "# polynomial expansion\n", + "step_poly = dbi.choose_step(scheduling=DoubleBracketScheduling.use_polynomial_approximation, d=d, n=5)\n", + "print('polynomial_approximation step:', step_poly)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Plot the results\n", + "plt.plot(s_space, off_diagonal_norm_diff)\n", + "plt.axvline(x=step_grid, color='r', linestyle='-',label='grid_search')\n", + "plt.axvline(x=step_hyperopt, color='g', linestyle='--',label='hyperopt')\n", + "plt.axvline(x=step_poly, color='m', linestyle='-.',label='polynomial')\n", + "plt.ylabel(r'$||\\sigma(H_0)||-\\sigma(H_k)||$')\n", + "plt.xlabel('s')\n", + "plt.title('hyperopt first step')\n", + "plt.legend()\n", + "print('The minimum for cost function in the tested range is:', step_grid)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We see that there are two similar \"minimal point\" at 0.03 and 0.22, with the latter being the absolute minimum by an insignificant advantage. However, for practical reasons, we prefer taking the first close-minimum calculated by polynomial approximation. Hence, we can use the polynomial approximation to restrict the search area and obtain better results. For example, we define a search range of 0.1 around the polynomial step." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Use polynomial expansion as an restriction of hyperopt/grid range" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "search_range = 0.1\n", + "if step_poly < search_range/2:\n", + " step_min = 0\n", + " step_max = search_range\n", + "else:\n", + " step_min = step_poly - search_range/2\n", + " step_max = step_poly + search_range/2\n", + "# grid_search\n", + "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.use_grid_search, step_min=step_min, step_max=step_max, d=d)\n", + "print('grid_search step:', step_grid)\n", + "# hyperopt\n", + "step_hyperopt = dbi.choose_step(scheduling=DoubleBracketScheduling.use_hyperopt, step_min=step_min, step_max=step_max, max_evals=100, d=d,)\n", + "print('hyperopt_search step:', step_hyperopt)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Plot the results\n", + "plt.plot(s_space, off_diagonal_norm_diff)\n", + "plt.axvline(x=step_grid, color='r', linestyle='-',label='grid_search')\n", + "plt.axvline(x=step_hyperopt, color='g', linestyle='--',label='hyperopt')\n", + "plt.axvline(x=step_poly, color='m', linestyle='-.',label='polynomial')\n", + "plt.ylabel(r'$||\\sigma(H_0)||-\\sigma(H_k)||$')\n", + "plt.xlabel('s')\n", + "plt.title('hyperopt first step')\n", + "plt.legend()\n", + "print('The minimum for cost function in the tested range is:', step_grid)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "DBF_qibo", + "language": "python", + "name": "python3" + }, + "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.11.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index 15ffdb007e..bb002d3f90 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -1,6 +1,8 @@ +import math from copy import deepcopy from enum import Enum, auto from functools import partial +from typing import Optional import hyperopt import numpy as np @@ -21,6 +23,17 @@ class DoubleBracketGeneratorType(Enum): # TODO: add double commutator (does it converge?) +class DoubleBracketScheduling(Enum): + """Define the DBI scheduling strategies.""" + + use_hyperopt = auto() + """Use hyperopt package.""" + use_grid_search = auto() + """Use greedy grid search.""" + use_polynomial_approximation = auto() + """Use polynomial expansion (analytical) of the loss function.""" + + class DoubleBracketIteration: """ Class implementing the Double Bracket iteration algorithm. @@ -49,10 +62,12 @@ def __init__( self, hamiltonian: Hamiltonian, mode: DoubleBracketGeneratorType = DoubleBracketGeneratorType.canonical, + scheduling: DoubleBracketScheduling = DoubleBracketScheduling.use_grid_search, ): self.h = hamiltonian self.h0 = deepcopy(self.h) self.mode = mode + self.scheduling = scheduling def __call__( self, step: float, mode: DoubleBracketGeneratorType = None, d: np.array = None @@ -115,6 +130,36 @@ def backend(self): """Get Hamiltonian's backend.""" return self.h0.backend + def grid_search_step( + self, + step_min: float = 1e-5, + step_max: float = 1, + num_evals: int = 100, + space: Optional[np.array] = None, + d: Optional[np.array] = None, + ): + """ + Greedy optimization of the iteration step. + + Args: + step_min: lower bound of the search grid; + step_max: upper bound of the search grid; + mnum_evals: number of iterations between step_min and step_max; + d: diagonal operator for generating double-bracket iterations. + + Returns: + (float): optimized best iteration step (minimizing off-diagonal norm). + """ + if space is None: + space = np.linspace(step_min, step_max, num_evals) + + if d is None: + d = self.diagonal_h_matrix + + loss_list = [self.loss(step, d=d) for step in space] + idx_max_loss = loss_list.index(min(loss_list)) + return space[idx_max_loss] + def hyperopt_step( self, step_min: float = 1e-5, @@ -124,10 +169,10 @@ def hyperopt_step( optimizer: callable = None, look_ahead: int = 1, verbose: bool = False, - d: np.array = None, + d: Optional[np.array] = None, ): """ - Optimize iteration step. + Optimize iteration step using hyperopt. Args: step_min: lower bound of the search grid; @@ -140,12 +185,14 @@ def hyperopt_step( d: diagonal operator for generating double-bracket iterations. Returns: - (float): optimized best iteration step. + (float): optimized best iteration step (minimizing off-diagonal norm). """ if space is None: space = hyperopt.hp.uniform if optimizer is None: optimizer = hyperopt.tpe + if d is None: + d = self.diagonal_h_matrix space = space("step", step_min, step_max) best = hyperopt.fmin( @@ -157,6 +204,92 @@ def hyperopt_step( ) return best["step"] + def polynomial_step( + self, + n: int = 3, + n_max: int = 5, + d: np.array = None, + backup_scheduling: DoubleBracketScheduling = DoubleBracketScheduling.use_grid_search, + ): + r""" + Optimizes iteration step by solving the n_th order polynomial expansion of the loss function. + e.g. $n=2$: $2\Trace(\sigma(\Gamma_1 + s\Gamma_2 + s^2/2\Gamma_3)\sigma(\Gamma_0 + s\Gamma_1 + s^2/2\Gamma_2)) + Args: + n (int, optional): The order to which the loss function is expanded. Defaults to 3. + n_max (int, optional): The maximum order allowed for recurring calls of `polynomial_step`. Defaults to 5. + d (np.array, optional): The diagonal operator, default as $\delta(H)$. + """ + + if d is None: + d = self.diagonal_h_matrix + + def sigma(h: np.array): + return h - self.backend.cast(np.diag(np.diag(self.backend.to_numpy(h)))) + + def Gamma(k: int): + r"""Computes the k_th Gamma function i.e $\Gamma_k=[W,...,[W,[W,H]]...]$, where we take k nested commutators with $W = [D, H]$""" + if k == 0: + return self.h.matrix + else: + W = self.commutator(d, sigma(self.h.matrix)) + result = self.h.matrix + for _ in range(k): + result = self.commutator(W, result) + return result + + # list starting from s^n highest order to s^0 + sigma_gamma_list = np.array([sigma(Gamma(k)) for k in range(n + 2)]) + exp_list = np.array([1 / math.factorial(k) for k in range(n + 1)]) + # coefficients for rotation with [W,H] and H + c1 = [ + exp_coef * delta_gamma + for exp_coef, delta_gamma in zip(exp_list, sigma_gamma_list[1:]) + ] + c2 = [ + exp_coef * delta_gamma + for exp_coef, delta_gamma in zip(exp_list, sigma_gamma_list[:-1]) + ] + # product coefficient + trace_coefficients = [0] * (2 * n + 1) + for k in range(n + 1): + for j in range(n + 1): + power = k + j + product_matrix = c1[k] @ c2[j] + trace_coefficients[power] += 2 * np.trace(product_matrix) + roots = np.roots(list(reversed(trace_coefficients[: n + 1]))) + error = 1e-3 + real_positive_roots = [ + np.real(root) + for root in roots + if np.imag(root) < error and np.real(root) > 0 + ] + # solution exists, return minimum s + if len(real_positive_roots) > 0: + return min(real_positive_roots) + # solution does not exist, resort to backup scheduling + elif ( + backup_scheduling == DoubleBracketScheduling.use_polynomial_approximation + and n < n_max + 1 + ): + return self.polynomial_step(d, n=n + 1, backup_scheduling=backup_scheduling) + else: + return self.choose_step(d, backup_scheduling) + + def choose_step( + self, + d: Optional[np.array] = None, + scheduling: Optional[DoubleBracketScheduling] = None, + **kwargs, + ): + if scheduling is None: + scheduling = self.scheduling + if scheduling is DoubleBracketScheduling.use_grid_search: + return self.grid_search_step(d=d, **kwargs) + if scheduling is DoubleBracketScheduling.use_hyperopt: + return self.hyperopt_step(d=d, **kwargs) + if scheduling is DoubleBracketScheduling.use_polynomial_approximation: + return self.polynomial_step(d=d, **kwargs) + def loss(self, step: float, d: np.array = None, look_ahead: int = 1): """ Compute loss function distance between `look_ahead` steps. From 5567114a50519c477569d4a2c6da6fea4e45aeef Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Mon, 29 Jan 2024 18:15:22 +0800 Subject: [PATCH 02/22] Tests for double_bracket.py scheduling: test_double_bracket_iteration_scheduling_polynomial; test_double_bracket_iteration_scheduling_grid_hyperopt --- examples/dbi/dbi_scheduling.ipynb | 11 +++- src/qibo/models/dbi/double_bracket.py | 11 +++- tests/test_models_dbi.py | 92 ++++++++++++++++++++------- 3 files changed, 87 insertions(+), 27 deletions(-) diff --git a/examples/dbi/dbi_scheduling.ipynb b/examples/dbi/dbi_scheduling.ipynb index 066d56640d..15f4de2339 100644 --- a/examples/dbi/dbi_scheduling.ipynb +++ b/examples/dbi/dbi_scheduling.ipynb @@ -65,7 +65,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We first generate the relationship between the step duration and the off-diagoanl norm (loss function) for the first step of the iteration." + "We first run a sweep of step duration to map the off-diagonal norm in this range." ] }, { @@ -152,7 +152,7 @@ "outputs": [], "source": [ "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator)\n", - "d = Z_op\n", + "d = ZI_op\n", "# generate data for plotting sigma decrease of the first step\n", "s_space = np.linspace(1e-5, 0.6, 100)\n", "off_diagonal_norm_diff = []\n", @@ -249,6 +249,13 @@ "plt.legend()\n", "print('The minimum for cost function in the tested range is:', step_grid)" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Hence, we see that the strategy is indeed effective for finding the first minimum of the loss funciton for both the Z operator and the ZI operator." + ] } ], "metadata": { diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index bb002d3f90..6749c378a8 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -209,7 +209,7 @@ def polynomial_step( n: int = 3, n_max: int = 5, d: np.array = None, - backup_scheduling: DoubleBracketScheduling = DoubleBracketScheduling.use_grid_search, + backup_scheduling: DoubleBracketScheduling = None, ): r""" Optimizes iteration step by solving the n_th order polynomial expansion of the loss function. @@ -223,6 +223,9 @@ def polynomial_step( if d is None: d = self.diagonal_h_matrix + if backup_scheduling is None: + backup_scheduling = DoubleBracketScheduling.use_grid_search + def sigma(h: np.array): return h - self.backend.cast(np.diag(np.diag(self.backend.to_numpy(h)))) @@ -271,9 +274,11 @@ def Gamma(k: int): backup_scheduling == DoubleBracketScheduling.use_polynomial_approximation and n < n_max + 1 ): - return self.polynomial_step(d, n=n + 1, backup_scheduling=backup_scheduling) + return self.polynomial_step( + n=n + 1, d=d, backup_scheduling=backup_scheduling + ) else: - return self.choose_step(d, backup_scheduling) + return self.choose_step(d=d, scheduling=backup_scheduling) def choose_step( self, diff --git a/tests/test_models_dbi.py b/tests/test_models_dbi.py index 90c0c1804b..6ee130f71e 100644 --- a/tests/test_models_dbi.py +++ b/tests/test_models_dbi.py @@ -6,74 +6,75 @@ from qibo.models.dbi.double_bracket import ( DoubleBracketGeneratorType, DoubleBracketIteration, + DoubleBracketScheduling, ) from qibo.quantum_info import random_hermitian -NSTEPS = 50 +NSTEPS = 1 """Number of steps for evolution.""" @pytest.mark.parametrize("nqubits", [3, 4, 5]) def test_double_bracket_iteration_canonical(backend, nqubits): h0 = random_hermitian(2**nqubits, backend=backend) - dbf = DoubleBracketIteration( + dbi = DoubleBracketIteration( Hamiltonian(nqubits, h0, backend=backend), mode=DoubleBracketGeneratorType.canonical, ) - initial_off_diagonal_norm = dbf.off_diagonal_norm + initial_off_diagonal_norm = dbi.off_diagonal_norm for _ in range(NSTEPS): - dbf(step=np.sqrt(0.001)) + dbi(step=np.sqrt(0.001)) - assert initial_off_diagonal_norm > dbf.off_diagonal_norm + assert initial_off_diagonal_norm > dbi.off_diagonal_norm @pytest.mark.parametrize("nqubits", [3, 4, 5]) def test_double_bracket_iteration_group_commutator(backend, nqubits): h0 = random_hermitian(2**nqubits, backend=backend) d = backend.cast(np.diag(np.diag(backend.to_numpy(h0)))) - dbf = DoubleBracketIteration( + dbi = DoubleBracketIteration( Hamiltonian(nqubits, h0, backend=backend), mode=DoubleBracketGeneratorType.group_commutator, ) - initial_off_diagonal_norm = dbf.off_diagonal_norm + initial_off_diagonal_norm = dbi.off_diagonal_norm with pytest.raises(ValueError): - dbf(mode=DoubleBracketGeneratorType.group_commutator, step=0.01) + dbi(mode=DoubleBracketGeneratorType.group_commutator, step=0.01) for _ in range(NSTEPS): - dbf(step=0.01, d=d) + dbi(step=0.01, d=d) - assert initial_off_diagonal_norm > dbf.off_diagonal_norm + assert initial_off_diagonal_norm > dbi.off_diagonal_norm @pytest.mark.parametrize("nqubits", [3, 4, 5]) def test_double_bracket_iteration_single_commutator(backend, nqubits): h0 = random_hermitian(2**nqubits, backend=backend) d = backend.cast(np.diag(np.diag(backend.to_numpy(h0)))) - dbf = DoubleBracketIteration( + dbi = DoubleBracketIteration( Hamiltonian(nqubits, h0, backend=backend), mode=DoubleBracketGeneratorType.single_commutator, ) - initial_off_diagonal_norm = dbf.off_diagonal_norm + initial_off_diagonal_norm = dbi.off_diagonal_norm for _ in range(NSTEPS): - dbf(step=0.01, d=d) - dbf(step=0.01) + dbi(step=0.01, d=d) + dbi(step=0.01) - assert initial_off_diagonal_norm > dbf.off_diagonal_norm + assert initial_off_diagonal_norm > dbi.off_diagonal_norm @pytest.mark.parametrize("nqubits", [3, 4, 5]) def test_hyperopt_step(backend, nqubits): h0 = random_hermitian(2**nqubits, backend=backend) d = backend.cast(np.diag(np.diag(backend.to_numpy(h0)))) - dbf = DoubleBracketIteration(Hamiltonian(nqubits, h0, backend=backend)) + dbi = DoubleBracketIteration(Hamiltonian(nqubits, h0, backend=backend)) # find initial best step with look_ahead = 1 initial_step = 0.01 delta = 0.02 - step = dbf.hyperopt_step( + step = dbi.hyperopt_step( step_min=initial_step - delta, step_max=initial_step + delta, max_evals=100 ) @@ -81,12 +82,12 @@ def test_hyperopt_step(backend, nqubits): # evolve following the optimized first step for generator in DoubleBracketGeneratorType: - dbf(mode=generator, step=step, d=d) + dbi(mode=generator, step=step, d=d) # find the following step size with look_ahead look_ahead = 3 - step = dbf.hyperopt_step( + step = dbi.hyperopt_step( step_min=initial_step - delta, step_max=initial_step + delta, max_evals=100, @@ -95,12 +96,59 @@ def test_hyperopt_step(backend, nqubits): # evolve following the optimized first step for gentype in range(look_ahead): - dbf(mode=DoubleBracketGeneratorType(gentype + 1), step=step, d=d) + dbi(mode=DoubleBracketGeneratorType(gentype + 1), step=step, d=d) def test_energy_fluctuations(backend): h0 = np.array([[1, 0], [0, -1]]) state = np.array([1, 0]) - dbf = DoubleBracketIteration(Hamiltonian(1, matrix=h0, backend=backend)) - energy_fluctuation = dbf.energy_fluctuation(state=state) + dbi = DoubleBracketIteration(Hamiltonian(1, matrix=h0, backend=backend)) + energy_fluctuation = dbi.energy_fluctuation(state=state) assert energy_fluctuation == 0 + + +@pytest.mark.parametrize( + "scheduling", + [DoubleBracketScheduling.use_grid_search, DoubleBracketScheduling.use_hyperopt], +) +@pytest.mark.parametrize("nqubits", [3, 4, 5]) +def test_double_bracket_iteration_scheduling_grid_hyperopt( + backend, nqubits, scheduling +): + h0 = random_hermitian(2**nqubits, backend=backend) + d = backend.cast(np.diag(np.diag(backend.to_numpy(h0)))) + dbi = DoubleBracketIteration( + Hamiltonian(nqubits, h0, backend=backend), + mode=DoubleBracketGeneratorType.single_commutator, + ) + initial_off_diagonal_norm = dbi.off_diagonal_norm + for _ in range(NSTEPS): + step1 = dbi.choose_step(d=d, scheduling=scheduling) + dbi(d=d, step=step1) + step2 = dbi.choose_step(scheduling=scheduling) + dbi(step=step2) + assert initial_off_diagonal_norm > dbi.off_diagonal_norm + + +@pytest.mark.parametrize("nqubits", [3, 4, 5]) +@pytest.mark.parametrize("n", [2, 3]) +@pytest.mark.parametrize( + "backup_scheduling", [None, DoubleBracketScheduling.use_polynomial_approximation] +) +def test_double_bracket_iteration_scheduling_polynomial( + backend, nqubits, n, backup_scheduling +): + h0 = random_hermitian(2**nqubits, backend=backend) + d = backend.cast(np.diag(np.diag(backend.to_numpy(h0)))) + dbi = DoubleBracketIteration( + Hamiltonian(nqubits, h0, backend=backend), + mode=DoubleBracketGeneratorType.single_commutator, + scheduling=DoubleBracketScheduling.use_polynomial_approximation, + ) + initial_off_diagonal_norm = dbi.off_diagonal_norm + for _ in range(NSTEPS): + step1 = dbi.polynomial_step(n=n, d=d, backup_scheduling=backup_scheduling) + dbi(d=d, step=step1) + step2 = dbi.polynomial_step(n=n) + dbi(step=step2) + assert initial_off_diagonal_norm > dbi.off_diagonal_norm From abddfaee79de8e68d2b2794d608937762b1de2ad Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Mon, 29 Jan 2024 23:58:15 +0800 Subject: [PATCH 03/22] Updated utils and Pauli-Z notebook for scheduling --- .../dbi/DBI_strategy_Pauli-Z_products.ipynb | 50 +++++-------------- src/qibo/models/dbi/utils.py | 27 +++------- 2 files changed, 20 insertions(+), 57 deletions(-) diff --git a/examples/dbi/DBI_strategy_Pauli-Z_products.ipynb b/examples/dbi/DBI_strategy_Pauli-Z_products.ipynb index 0f76a36245..d89fdd5e74 100644 --- a/examples/dbi/DBI_strategy_Pauli-Z_products.ipynb +++ b/examples/dbi/DBI_strategy_Pauli-Z_products.ipynb @@ -28,7 +28,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -122,31 +122,16 @@ }, { "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.4|INFO|2024-01-24 19:59:31]: Using qibojit (numba) backend on /CPU:0\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Initial off diagonal norm 8.48528137423857\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# set the qibo backend (we suggest qibojit if N >= 20)\n", "# alternatives: tensorflow (not optimized), numpy (when CPU not supported by jit)\n", "set_backend(\"qibojit\", \"numba\")\n", "\n", "# hamiltonian parameters\n", - "nqubits = 2\n", + "nqubits = 5\n", "h = 3\n", "\n", "# define the hamiltonian\n", @@ -160,20 +145,9 @@ }, { "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[-2.-0.j -0.-0.j -0.-0.j -0.-0.j]\n", - " [-0.-0.j 2.-0.j -0.-0.j -0.-0.j]\n", - " [-0.-0.j -0.-0.j 2.-0.j -0.-0.j]\n", - " [-0.-0.j -0.-0.j -0.-0.j -2.-0.j]]\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "print(H_TFIM.matrix)" ] @@ -219,8 +193,9 @@ "# add in initial values for plotting\n", "off_diagonal_norm_history = [dbi.off_diagonal_norm]\n", "steps = [0]\n", + "scheduling = DoubleBracketScheduling.use_hyperopt\n", "for _ in range(NSTEPS):\n", - " dbi, idx, step, flip_sign = select_best_dbr_generator(dbi, Z_ops, compare_canonical=False, max_evals=max_evals, step_max=step_max)\n", + " dbi, idx, step, flip_sign = select_best_dbr_generator(dbi, Z_ops, scheduling=scheduling, compare_canonical=False, max_evals=max_evals, step_max=step_max)\n", " off_diagonal_norm_history.append(dbi.off_diagonal_norm)\n", " steps.append(steps[-1]+step)\n", " if flip_sign < 0:\n", @@ -294,7 +269,6 @@ " step_max = 1,\n", " space = hp.uniform,\n", " optimizer = tpe,\n", - " max_evals = max_evals,\n", " )\n", " dbi_canonical(step=step)\n", " print(f\"New optimized step at iteration {s+1}/{NSTEPS}: {step}, loss {dbi_canonical.off_diagonal_norm}\")\n", @@ -389,7 +363,7 @@ "off_diagonal_norm_history_mixed = [dbi_mixed.off_diagonal_norm]\n", "steps = [0]\n", "for _ in range(NSTEPS):\n", - " dbi_mixed, idx, step, flip_sign = select_best_dbr_generator(dbi_mixed, Z_ops, compare_canonical=True, max_evals=max_evals)\n", + " dbi_mixed, idx, step, flip_sign = select_best_dbr_generator(dbi_mixed, Z_ops, scheduling=scheduling, compare_canonical=True, max_evals=max_evals, step_max=step_max)\n", " off_diagonal_norm_history_mixed.append(dbi_mixed.off_diagonal_norm)\n", " steps.append(steps[-1]+step)\n", " if idx == len(Z_ops):\n", @@ -479,7 +453,7 @@ "remaining_NSTEPS = NSTEPS - cannonical_NSTEPS\n", "dbi_mixed_can.mode = DoubleBracketGeneratorType.single_commutator\n", "for _ in range(remaining_NSTEPS):\n", - " dbi_mixed_can, idx, step, flip_sign = select_best_dbr_generator(dbi_mixed_can, Z_ops, compare_canonical=False)\n", + " dbi_mixed_can, idx, step, flip_sign = select_best_dbr_generator(dbi_mixed_can, Z_ops, scheduling=scheduling, compare_canonical=False, max_evals=max_evals, step_max=step_max)\n", " off_diagonal_norm_history_mixed_can.append(dbi_mixed_can.off_diagonal_norm)\n", " steps_mixed_can.append(step)\n", " if idx == len(Z_ops):\n", diff --git a/src/qibo/models/dbi/utils.py b/src/qibo/models/dbi/utils.py index 5969637b62..f354a9398b 100644 --- a/src/qibo/models/dbi/utils.py +++ b/src/qibo/models/dbi/utils.py @@ -11,6 +11,7 @@ from qibo.models.dbi.double_bracket import ( DoubleBracketGeneratorType, DoubleBracketIteration, + DoubleBracketScheduling, ) @@ -71,11 +72,9 @@ def select_best_dbr_generator( dbi_object: DoubleBracketIteration, d_list: list, step: Optional[float] = None, - step_min: float = 1e-5, - step_max: float = 1, - max_evals: int = 200, compare_canonical: bool = True, - mode: DoubleBracketGeneratorType = DoubleBracketGeneratorType.single_commutator, + scheduling: DoubleBracketScheduling = None, + **kwargs, ): """Selects the best double bracket rotation generator from a list and runs the @@ -88,11 +87,12 @@ def select_best_dbr_generator( step_max (float): Maximally allowed iteration duration. max_evals (int): Maximally allowed number of evaluation in hyperopt. compare_canonical (bool): If `True`, the optimal diagonal operator chosen from "d_list" is compared with the canonical bracket. - mode (_DoubleBracketGeneratorType): DBI generator type used for the selection. Returns: The updated dbi_object, index of the optimal diagonal operator, respective step duration, and evolution direction. """ + if scheduling is None: + scheduling = dbi_object.scheduling norms_off_diagonal_restriction = [ dbi_object.off_diagonal_norm for _ in range(len(d_list)) ] @@ -104,13 +104,8 @@ def select_best_dbr_generator( flip_list[i] = CS_angle_sgn(dbi_eval, d) if flip_list[i] != 0: if step is None: - step_best = dbi_eval.hyperopt_step( - d=flip_list[i] * d, - step_min=step_min, - step_max=step_max, - space=hp.uniform, - optimizer=tpe, - max_evals=max_evals, + step_best = dbi_eval.choose_step( + d=flip_list[i] * d, scheduling=scheduling, **kwargs ) else: step_best = step @@ -123,13 +118,7 @@ def select_best_dbr_generator( dbi_eval = deepcopy(dbi_object) dbi_eval.mode = DoubleBracketGeneratorType.canonical if step is None: - step_best = dbi_eval.hyperopt_step( - step_min=step_min, - step_max=step_max, - space=hp.uniform, - optimizer=tpe, - max_evals=max_evals, - ) + step_best = dbi_eval.choose_step(scheduling=scheduling, **kwargs) else: step_best = step dbi_eval(step=step_best) From 1948c012166fec7c92e3bc6307c79b8ece389646 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Tue, 30 Jan 2024 14:34:55 +0800 Subject: [PATCH 04/22] Notebook section shows difference of scheduling techniques in Pauli-Z strategies --- examples/dbi/dbi_scheduling.ipynb | 110 ++++++++++++++++++++++++++++-- 1 file changed, 106 insertions(+), 4 deletions(-) diff --git a/examples/dbi/dbi_scheduling.ipynb b/examples/dbi/dbi_scheduling.ipynb index 15f4de2339..275d2dea73 100644 --- a/examples/dbi/dbi_scheduling.ipynb +++ b/examples/dbi/dbi_scheduling.ipynb @@ -170,13 +170,16 @@ "source": [ "# grid_search\n", "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.use_grid_search, step_max=0.6, d=d)\n", - "print('grid_search step:', step_grid)\n", + "grid_min = dbi.loss(step=step_grid, d=d)-dbi.off_diagonal_norm\n", + "print('grid_search step:', step_grid, 'loss', grid_min)\n", "# hyperopt\n", "step_hyperopt = dbi.choose_step(scheduling=DoubleBracketScheduling.use_hyperopt, d=d, max_evals=100, step_max=0.6)\n", - "print('hyperopt_search step:', step_hyperopt)\n", + "hyperopt_min = dbi.loss(step=step_hyperopt, d=d)-dbi.off_diagonal_norm\n", + "print('hyperopt_search step:', step_hyperopt, 'loss', hyperopt_min)\n", "# polynomial expansion\n", "step_poly = dbi.choose_step(scheduling=DoubleBracketScheduling.use_polynomial_approximation, d=d, n=5)\n", - "print('polynomial_approximation step:', step_poly)" + "poly_min = dbi.loss(step=step_poly, d=d)-dbi.off_diagonal_norm\n", + "print('polynomial_approximation step:', step_poly, 'loss', poly_min)" ] }, { @@ -188,6 +191,8 @@ "# Plot the results\n", "plt.plot(s_space, off_diagonal_norm_diff)\n", "plt.axvline(x=step_grid, color='r', linestyle='-',label='grid_search')\n", + "plt.text(x=step_grid, y=grid_min, s=f'grid min \\n{round(grid_min,3)}')\n", + "plt.text(x=step_poly, y=poly_min, s=f'grid min \\n{round(poly_min,3)}')\n", "plt.axvline(x=step_hyperopt, color='g', linestyle='--',label='hyperopt')\n", "plt.axvline(x=step_poly, color='m', linestyle='-.',label='polynomial')\n", "plt.ylabel(r'$||\\sigma(H_0)||-\\sigma(H_k)||$')\n", @@ -208,7 +213,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Use polynomial expansion as an restriction of hyperopt/grid range" + "## Use polynomial expansion as an restriction for hyperopt/grid range" ] }, { @@ -256,6 +261,103 @@ "source": [ "Hence, we see that the strategy is indeed effective for finding the first minimum of the loss funciton for both the Z operator and the ZI operator." ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Compare in Pauli-Z strategy" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qibo.quantum_info import random_hermitian\n", + "from qibo.hamiltonians import Hamiltonian" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Hamiltonian\n", + "set_backend(\"qibojit\", \"numba\")\n", + "nqubits = 4\n", + "h0 = random_hermitian(2**nqubits)\n", + "\n", + "# initialize class\n", + "dbi = DoubleBracketIteration(deepcopy(Hamiltonian(nqubits=nqubits, matrix=h0)),mode=DoubleBracketGeneratorType.single_commutator)\n", + "print(\"Initial off diagonal norm\", dbi.off_diagonal_norm)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "generate_local_Z = generate_Z_operators(nqubits)\n", + "Z_ops = list(generate_local_Z.values())\n", + "Z_names = list(generate_local_Z.keys())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "NSTEPS = 8\n", + "scheduling_list = [DoubleBracketScheduling.use_grid_search,\n", + " DoubleBracketScheduling.use_hyperopt,\n", + " DoubleBracketScheduling.use_polynomial_approximation,]\n", + "scheduling_labels = ['grid search',\n", + " 'hyperopt',\n", + " 'polynomial',]\n", + "Z_optimal_scheduling = []\n", + "s_scheduling = []\n", + "off_norm_scheduling =[]\n", + "for i,scheduling in enumerate(scheduling_list):\n", + " # reinitialize\n", + " dbi = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=deepcopy(h0)), mode=DoubleBracketGeneratorType.single_commutator)\n", + " Z_optimal = []\n", + " # add in initial values for plotting\n", + " off_diagonal_norm_history = [dbi.off_diagonal_norm]\n", + " steps = [0]\n", + " print(f'----------Scheduling {scheduling_labels[i]}----------')\n", + " for _ in range(NSTEPS):\n", + " dbi, idx, step, flip_sign = select_best_dbr_generator(dbi, Z_ops, scheduling=scheduling, compare_canonical=False)\n", + " off_diagonal_norm_history.append(dbi.off_diagonal_norm)\n", + " steps.append(steps[-1]+step)\n", + " if flip_sign < 0:\n", + " Z_optimal.append('-' + Z_names[idx])\n", + " else:\n", + " Z_optimal.append(Z_names[idx])\n", + " print(f\"New optimized step at iteration {_+1}/{NSTEPS}: {step} with operator {Z_optimal[-1]}, loss {dbi.off_diagonal_norm}\")\n", + " Z_optimal_scheduling.append(Z_optimal)\n", + " s_scheduling.append(steps)\n", + " off_norm_scheduling.append(off_diagonal_norm_history)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.figure()\n", + "for i, scheduling in enumerate(scheduling_labels):\n", + " plt.plot(s_scheduling[i], off_norm_scheduling[i], '-o', label=scheduling)\n", + "plt.xlabel(\"Iterations\")\n", + "plt.ylabel(\"Norm off-diagonal restriction\")\n", + "plt.title(\"Compare Variational Pauli-Z using different scheduling strategies\")\n", + "plt.legend()" + ] } ], "metadata": { From 588a02ae89162aadb7cbe7a22bcbaa6b28ebe325 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Thu, 15 Feb 2024 01:11:01 +0000 Subject: [PATCH 05/22] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- tests/test_models_dbi_utils.py | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/test_models_dbi_utils.py b/tests/test_models_dbi_utils.py index 1c7f825c01..89e2ce9b0d 100644 --- a/tests/test_models_dbi_utils.py +++ b/tests/test_models_dbi_utils.py @@ -1,4 +1,5 @@ """"Testing utils for DoubleBracketIteration model""" + import numpy as np import pytest From 9d663cbb21a32802174b4b9fdc745ce9705a0e41 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Thu, 15 Feb 2024 13:54:12 +0800 Subject: [PATCH 06/22] Fix test random hamiltonian seed for test coverage stability --- tests/test_models_dbi.py | 21 ++++++++++++--------- 1 file changed, 12 insertions(+), 9 deletions(-) diff --git a/tests/test_models_dbi.py b/tests/test_models_dbi.py index 6ee130f71e..3d1a72e57d 100644 --- a/tests/test_models_dbi.py +++ b/tests/test_models_dbi.py @@ -11,12 +11,13 @@ from qibo.quantum_info import random_hermitian NSTEPS = 1 +seed = 10 """Number of steps for evolution.""" @pytest.mark.parametrize("nqubits", [3, 4, 5]) def test_double_bracket_iteration_canonical(backend, nqubits): - h0 = random_hermitian(2**nqubits, backend=backend) + h0 = random_hermitian(2**nqubits, backend=backend, seed=seed) dbi = DoubleBracketIteration( Hamiltonian(nqubits, h0, backend=backend), mode=DoubleBracketGeneratorType.canonical, @@ -30,7 +31,7 @@ def test_double_bracket_iteration_canonical(backend, nqubits): @pytest.mark.parametrize("nqubits", [3, 4, 5]) def test_double_bracket_iteration_group_commutator(backend, nqubits): - h0 = random_hermitian(2**nqubits, backend=backend) + h0 = random_hermitian(2**nqubits, backend=backend, seed=seed) d = backend.cast(np.diag(np.diag(backend.to_numpy(h0)))) dbi = DoubleBracketIteration( Hamiltonian(nqubits, h0, backend=backend), @@ -49,7 +50,7 @@ def test_double_bracket_iteration_group_commutator(backend, nqubits): @pytest.mark.parametrize("nqubits", [3, 4, 5]) def test_double_bracket_iteration_single_commutator(backend, nqubits): - h0 = random_hermitian(2**nqubits, backend=backend) + h0 = random_hermitian(2**nqubits, backend=backend, seed=seed) d = backend.cast(np.diag(np.diag(backend.to_numpy(h0)))) dbi = DoubleBracketIteration( Hamiltonian(nqubits, h0, backend=backend), @@ -66,7 +67,7 @@ def test_double_bracket_iteration_single_commutator(backend, nqubits): @pytest.mark.parametrize("nqubits", [3, 4, 5]) def test_hyperopt_step(backend, nqubits): - h0 = random_hermitian(2**nqubits, backend=backend) + h0 = random_hermitian(2**nqubits, backend=backend, seed=seed) d = backend.cast(np.diag(np.diag(backend.to_numpy(h0)))) dbi = DoubleBracketIteration(Hamiltonian(nqubits, h0, backend=backend)) @@ -115,7 +116,7 @@ def test_energy_fluctuations(backend): def test_double_bracket_iteration_scheduling_grid_hyperopt( backend, nqubits, scheduling ): - h0 = random_hermitian(2**nqubits, backend=backend) + h0 = random_hermitian(2**nqubits, backend=backend, seed=seed) d = backend.cast(np.diag(np.diag(backend.to_numpy(h0)))) dbi = DoubleBracketIteration( Hamiltonian(nqubits, h0, backend=backend), @@ -125,12 +126,12 @@ def test_double_bracket_iteration_scheduling_grid_hyperopt( for _ in range(NSTEPS): step1 = dbi.choose_step(d=d, scheduling=scheduling) dbi(d=d, step=step1) - step2 = dbi.choose_step(scheduling=scheduling) + step2 = dbi.choose_step() dbi(step=step2) assert initial_off_diagonal_norm > dbi.off_diagonal_norm -@pytest.mark.parametrize("nqubits", [3, 4, 5]) +@pytest.mark.parametrize("nqubits", [3, 4, 6]) @pytest.mark.parametrize("n", [2, 3]) @pytest.mark.parametrize( "backup_scheduling", [None, DoubleBracketScheduling.use_polynomial_approximation] @@ -138,7 +139,7 @@ def test_double_bracket_iteration_scheduling_grid_hyperopt( def test_double_bracket_iteration_scheduling_polynomial( backend, nqubits, n, backup_scheduling ): - h0 = random_hermitian(2**nqubits, backend=backend) + h0 = random_hermitian(2**nqubits, backend=backend, seed=seed) d = backend.cast(np.diag(np.diag(backend.to_numpy(h0)))) dbi = DoubleBracketIteration( Hamiltonian(nqubits, h0, backend=backend), @@ -149,6 +150,8 @@ def test_double_bracket_iteration_scheduling_polynomial( for _ in range(NSTEPS): step1 = dbi.polynomial_step(n=n, d=d, backup_scheduling=backup_scheduling) dbi(d=d, step=step1) - step2 = dbi.polynomial_step(n=n) + step2 = dbi.choose_step( + scheduling=DoubleBracketScheduling.use_polynomial_approximation, n=n + ) dbi(step=step2) assert initial_off_diagonal_norm > dbi.off_diagonal_norm From bfec99629bfa29d434aedbd284597bdb1f999db8 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Wed, 28 Feb 2024 15:09:23 +0800 Subject: [PATCH 07/22] Complete the merge in docstring --- src/qibo/models/dbi/utils.py | 30 ++++++++++-------------------- 1 file changed, 10 insertions(+), 20 deletions(-) diff --git a/src/qibo/models/dbi/utils.py b/src/qibo/models/dbi/utils.py index 75e1fa6de7..52f8a33294 100644 --- a/src/qibo/models/dbi/utils.py +++ b/src/qibo/models/dbi/utils.py @@ -78,26 +78,16 @@ def select_best_dbr_generator( ): """Selects the best double bracket rotation generator from a list and runs the - Args: - dbi_object (`DoubleBracketIteration`): the target DoubleBracketIteration object. - d_list (list): list of diagonal operators (np.array) to run from. - step (float): fixed iteration duration. - Defaults to ``None``, uses hyperopt. - <<<<<<< HEAD - step_min (float): Minimally allowed iteration duration. - step_max (float): Maximally allowed iteration duration. - max_evals (int): Maximally allowed number of evaluation in hyperopt. - compare_canonical (bool): If `True`, the optimal diagonal operator chosen from "d_list" is compared with the canonical bracket. - ======= - step_min (float): minimally allowed iteration duration. - step_max (float): maximally allowed iteration duration. - max_evals (int): maximally allowed number of evaluation in hyperopt. - compare_canonical (bool): if `True`, the optimal diagonal operator chosen from "d_list" is compared with the canonical bracket. - mode (`DoubleBracketGeneratorType`): DBI generator type used for the selection. - >>>>>>> 056830fff9eedef0da2003a638ce4dbd30b6e3b8 - - Returns: - The updated dbi_object, index of the optimal diagonal operator, respective step duration, and evolution direction. + Args: + dbi_object (`DoubleBracketIteration`): the target DoubleBracketIteration object. + d_list (list): list of diagonal operators (np.array) to run from. + step (float): fixed iteration duration. + Defaults to ``None``, optimize with `scheduling` method and `choose_step` function. + compare_canonical (boolean): if `True`, the diagonalization effect with operators from `d_list` is compared with the canonical bracket. + scheduling (`DoubleBracketScheduling`): scheduling method for finding the optimal step. + + Returns: + The updated dbi_object, index of the optimal diagonal operator, respective step duration, and evolution direction. """ if scheduling is None: scheduling = dbi_object.scheduling From 54ced5bd2525c5322c305a7807ea50c414be9f7c Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Wed, 28 Feb 2024 15:20:41 +0800 Subject: [PATCH 08/22] Remove `use` in scheduling names --- examples/dbi/dbi_scheduling.ipynb | 35 ++++++++++++++++++--------- src/qibo/models/dbi/double_bracket.py | 18 +++++++------- tests/test_models_dbi.py | 8 +++--- 3 files changed, 36 insertions(+), 25 deletions(-) diff --git a/examples/dbi/dbi_scheduling.ipynb b/examples/dbi/dbi_scheduling.ipynb index 275d2dea73..1f53822023 100644 --- a/examples/dbi/dbi_scheduling.ipynb +++ b/examples/dbi/dbi_scheduling.ipynb @@ -87,7 +87,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The default scheduling strategy is grid search: `DoubleBracketScheduling.use_grid_serach`. This strategy specifies a list of step durations to test one by one and finds the one that maximizes the cost function (off-digonal norm of Hamiltonian)" + "The default scheduling strategy is grid search: `DoubleBracketScheduling.\n", + "grid_serach`. This strategy specifies a list of step durations to test one by one and finds the one that maximizes the cost function (off-digonal norm of Hamiltonian)" ] }, { @@ -97,16 +98,26 @@ "outputs": [], "source": [ "# grid_search\n", - "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.use_grid_search)\n", + "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.grid_search)\n", "print('grid_search step:', step_grid)\n", "# hyperopt\n", - "step_hyperopt = dbi.choose_step(scheduling=DoubleBracketScheduling.use_hyperopt, max_evals=100, step_max=0.6)\n", + "step_hyperopt = dbi.choose_step(scheduling=DoubleBracketScheduling.hyperopt, max_evals=100, step_max=0.6)\n", "print('hyperopt_search step:', step_hyperopt)\n", "# polynomial expansion\n", - "step_poly = dbi.choose_step(scheduling=DoubleBracketScheduling.use_polynomial_approximation, n=5)\n", + "step_poly = dbi.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation, n=5)\n", "print('polynomial_approximation step:', step_poly)" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "step_poly = dbi.polynomial_step(n=5)\n", + "print(step_poly)" + ] + }, { "cell_type": "code", "execution_count": null, @@ -169,15 +180,15 @@ "outputs": [], "source": [ "# grid_search\n", - "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.use_grid_search, step_max=0.6, d=d)\n", + "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.grid_search, step_max=0.6, d=d)\n", "grid_min = dbi.loss(step=step_grid, d=d)-dbi.off_diagonal_norm\n", "print('grid_search step:', step_grid, 'loss', grid_min)\n", "# hyperopt\n", - "step_hyperopt = dbi.choose_step(scheduling=DoubleBracketScheduling.use_hyperopt, d=d, max_evals=100, step_max=0.6)\n", + "step_hyperopt = dbi.choose_step(scheduling=DoubleBracketScheduling.hyperopt, d=d, max_evals=100, step_max=0.6)\n", "hyperopt_min = dbi.loss(step=step_hyperopt, d=d)-dbi.off_diagonal_norm\n", "print('hyperopt_search step:', step_hyperopt, 'loss', hyperopt_min)\n", "# polynomial expansion\n", - "step_poly = dbi.choose_step(scheduling=DoubleBracketScheduling.use_polynomial_approximation, d=d, n=5)\n", + "step_poly = dbi.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation, d=d, n=5)\n", "poly_min = dbi.loss(step=step_poly, d=d)-dbi.off_diagonal_norm\n", "print('polynomial_approximation step:', step_poly, 'loss', poly_min)" ] @@ -230,10 +241,10 @@ " step_min = step_poly - search_range/2\n", " step_max = step_poly + search_range/2\n", "# grid_search\n", - "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.use_grid_search, step_min=step_min, step_max=step_max, d=d)\n", + "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.grid_search, step_min=step_min, step_max=step_max, d=d)\n", "print('grid_search step:', step_grid)\n", "# hyperopt\n", - "step_hyperopt = dbi.choose_step(scheduling=DoubleBracketScheduling.use_hyperopt, step_min=step_min, step_max=step_max, max_evals=100, d=d,)\n", + "step_hyperopt = dbi.choose_step(scheduling=DoubleBracketScheduling.hyperopt, step_min=step_min, step_max=step_max, max_evals=100, d=d,)\n", "print('hyperopt_search step:', step_hyperopt)" ] }, @@ -313,9 +324,9 @@ "outputs": [], "source": [ "NSTEPS = 8\n", - "scheduling_list = [DoubleBracketScheduling.use_grid_search,\n", - " DoubleBracketScheduling.use_hyperopt,\n", - " DoubleBracketScheduling.use_polynomial_approximation,]\n", + "scheduling_list = [DoubleBracketScheduling.grid_search,\n", + " DoubleBracketScheduling.hyperopt,\n", + " DoubleBracketScheduling.polynomial_approximation,]\n", "scheduling_labels = ['grid search',\n", " 'hyperopt',\n", " 'polynomial',]\n", diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index 1d1d48d6c9..1dbfc50b56 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -25,11 +25,11 @@ class DoubleBracketGeneratorType(Enum): class DoubleBracketScheduling(Enum): """Define the DBI scheduling strategies.""" - use_hyperopt = auto() + hyperopt = auto() """Use hyperopt package.""" - use_grid_search = auto() + grid_search = auto() """Use greedy grid search.""" - use_polynomial_approximation = auto() + polynomial_approximation = auto() """Use polynomial expansion (analytical) of the loss function.""" @@ -61,7 +61,7 @@ def __init__( self, hamiltonian: Hamiltonian, mode: DoubleBracketGeneratorType = DoubleBracketGeneratorType.canonical, - scheduling: DoubleBracketScheduling = DoubleBracketScheduling.use_grid_search, + scheduling: DoubleBracketScheduling = DoubleBracketScheduling.grid_search, ): self.h = hamiltonian self.h0 = deepcopy(self.h) @@ -223,7 +223,7 @@ def polynomial_step( d = self.diagonal_h_matrix if backup_scheduling is None: - backup_scheduling = DoubleBracketScheduling.use_grid_search + backup_scheduling = DoubleBracketScheduling.grid_search def sigma(h: np.array): return h - self.backend.cast(np.diag(np.diag(self.backend.to_numpy(h)))) @@ -270,7 +270,7 @@ def Gamma(k: int): return min(real_positive_roots) # solution does not exist, resort to backup scheduling elif ( - backup_scheduling == DoubleBracketScheduling.use_polynomial_approximation + backup_scheduling == DoubleBracketScheduling.polynomial_approximation and n < n_max + 1 ): return self.polynomial_step( @@ -287,11 +287,11 @@ def choose_step( ): if scheduling is None: scheduling = self.scheduling - if scheduling is DoubleBracketScheduling.use_grid_search: + if scheduling is DoubleBracketScheduling.grid_search: return self.grid_search_step(d=d, **kwargs) - if scheduling is DoubleBracketScheduling.use_hyperopt: + if scheduling is DoubleBracketScheduling.hyperopt: return self.hyperopt_step(d=d, **kwargs) - if scheduling is DoubleBracketScheduling.use_polynomial_approximation: + if scheduling is DoubleBracketScheduling.polynomial_approximation: return self.polynomial_step(d=d, **kwargs) def loss(self, step: float, d: np.array = None, look_ahead: int = 1): diff --git a/tests/test_models_dbi.py b/tests/test_models_dbi.py index 07904c551e..a573c32088 100644 --- a/tests/test_models_dbi.py +++ b/tests/test_models_dbi.py @@ -112,7 +112,7 @@ def test_energy_fluctuations(backend): @pytest.mark.parametrize( "scheduling", - [DoubleBracketScheduling.use_grid_search, DoubleBracketScheduling.use_hyperopt], + [DoubleBracketScheduling.grid_search, DoubleBracketScheduling.hyperopt], ) @pytest.mark.parametrize("nqubits", [3, 4, 5]) def test_double_bracket_iteration_scheduling_grid_hyperopt( @@ -136,7 +136,7 @@ def test_double_bracket_iteration_scheduling_grid_hyperopt( @pytest.mark.parametrize("nqubits", [3, 4, 6]) @pytest.mark.parametrize("n", [2, 3]) @pytest.mark.parametrize( - "backup_scheduling", [None, DoubleBracketScheduling.use_polynomial_approximation] + "backup_scheduling", [None, DoubleBracketScheduling.polynomial_approximation] ) def test_double_bracket_iteration_scheduling_polynomial( backend, nqubits, n, backup_scheduling @@ -146,14 +146,14 @@ def test_double_bracket_iteration_scheduling_polynomial( dbi = DoubleBracketIteration( Hamiltonian(nqubits, h0, backend=backend), mode=DoubleBracketGeneratorType.single_commutator, - scheduling=DoubleBracketScheduling.use_polynomial_approximation, + scheduling=DoubleBracketScheduling.polynomial_approximation, ) initial_off_diagonal_norm = dbi.off_diagonal_norm for _ in range(NSTEPS): step1 = dbi.polynomial_step(n=n, d=d, backup_scheduling=backup_scheduling) dbi(d=d, step=step1) step2 = dbi.choose_step( - scheduling=DoubleBracketScheduling.use_polynomial_approximation, n=n + scheduling=DoubleBracketScheduling.polynomial_approximation, n=n ) dbi(step=step2) assert initial_off_diagonal_norm > dbi.off_diagonal_norm From 4b9dc91c3acc7ca1aa9524e81341579cfc0ae105 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Wed, 28 Feb 2024 15:31:04 +0800 Subject: [PATCH 09/22] Complete docstring; set default polynomial order to even number 4. --- src/qibo/models/dbi/double_bracket.py | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index 1dbfc50b56..d017b32d7f 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -205,7 +205,7 @@ def hyperopt_step( def polynomial_step( self, - n: int = 3, + n: int = 4, n_max: int = 5, d: np.array = None, backup_scheduling: DoubleBracketScheduling = None, @@ -214,9 +214,10 @@ def polynomial_step( Optimizes iteration step by solving the n_th order polynomial expansion of the loss function. e.g. $n=2$: $2\Trace(\sigma(\Gamma_1 + s\Gamma_2 + s^2/2\Gamma_3)\sigma(\Gamma_0 + s\Gamma_1 + s^2/2\Gamma_2)) Args: - n (int, optional): The order to which the loss function is expanded. Defaults to 3. - n_max (int, optional): The maximum order allowed for recurring calls of `polynomial_step`. Defaults to 5. - d (np.array, optional): The diagonal operator, default as $\delta(H)$. + n (int, optional): the order to which the loss function is expanded. Defaults to 4. + n_max (int, optional): maximum order allowed for recurring calls of `polynomial_step`. Defaults to 5. + d (np.array, optional): diagonal operator, default as $\delta(H)$. + backup_scheduling (`DoubleBracketScheduling`): the scheduling method to use in case no real positive roots are found. """ if d is None: @@ -259,6 +260,7 @@ def Gamma(k: int): product_matrix = c1[k] @ c2[j] trace_coefficients[power] += 2 * np.trace(product_matrix) roots = np.roots(list(reversed(trace_coefficients[: n + 1]))) + print(list(reversed(trace_coefficients[: n + 1]))) error = 1e-3 real_positive_roots = [ np.real(root) From c5ab13e2f5e8c5f011686d925f091213dc4f53e4 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Wed, 28 Feb 2024 18:16:14 +0800 Subject: [PATCH 10/22] Remove print line --- src/qibo/models/dbi/double_bracket.py | 1 - 1 file changed, 1 deletion(-) diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index d017b32d7f..2c160ea525 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -260,7 +260,6 @@ def Gamma(k: int): product_matrix = c1[k] @ c2[j] trace_coefficients[power] += 2 * np.trace(product_matrix) roots = np.roots(list(reversed(trace_coefficients[: n + 1]))) - print(list(reversed(trace_coefficients[: n + 1]))) error = 1e-3 real_positive_roots = [ np.real(root) From 80d2604d6362151c7a2a50b5a7b623a462622618 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Fri, 1 Mar 2024 14:28:50 +0800 Subject: [PATCH 11/22] Backup scheduling moved to `choose_step` --- examples/dbi/dbi_scheduling.ipynb | 382 +++++++++++++++++++++++--- src/qibo/models/dbi/double_bracket.py | 60 +++- 2 files changed, 383 insertions(+), 59 deletions(-) diff --git a/examples/dbi/dbi_scheduling.ipynb b/examples/dbi/dbi_scheduling.ipynb index 1f53822023..686156fa4c 100644 --- a/examples/dbi/dbi_scheduling.ipynb +++ b/examples/dbi/dbi_scheduling.ipynb @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -42,9 +42,24 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.5|INFO|2024-03-01 14:04:46]: Using qibojit (numba) backend on /CPU:0\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initial off diagonal norm 37.94733192202055\n" + ] + } + ], "source": [ "# Hamiltonian\n", "set_backend(\"qibojit\", \"numba\")\n", @@ -70,7 +85,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -93,9 +108,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "grid_search step: 0.030312727272727272\n", + "hyperopt_search step: 0.029554880094525483\n", + "polynomial_approximation step: 0.032960905003724034\n" + ] + } + ], "source": [ "# grid_search\n", "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.grid_search)\n", @@ -103,26 +128,33 @@ "# hyperopt\n", "step_hyperopt = dbi.choose_step(scheduling=DoubleBracketScheduling.hyperopt, max_evals=100, step_max=0.6)\n", "print('hyperopt_search step:', step_hyperopt)\n", - "# polynomial expansion\n", "step_poly = dbi.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation, n=5)\n", "print('polynomial_approximation step:', step_poly)" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "step_poly = dbi.polynomial_step(n=5)\n", - "print(step_poly)" - ] - }, - { - "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The minimum for cost function in the tested range is: 0.030312727272727272\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Plot the results\n", "plt.plot(s_space, off_diagonal_norm_diff)\n", @@ -131,7 +163,7 @@ "plt.axvline(x=step_poly, color='m', linestyle='-.',label='polynomial')\n", "plt.ylabel(r'$||\\sigma(H_0)||-\\sigma(H_k)||$')\n", "plt.xlabel('s')\n", - "plt.title('hyperopt first step')\n", + "plt.title('First DBI step')\n", "plt.legend()\n", "print('The minimum for cost function in the tested range is:', step_grid)" ] @@ -147,23 +179,36 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 46, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.5|WARNING|2024-03-01 13:36:46]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-01 13:36:46]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + ] + } + ], "source": [ "# Generate the digaonal operators\n", - "Z_op = SymbolicHamiltonian(str_to_symbolic(\"Z\"*nqubits)).dense.matrix\n", - "ZI_op = SymbolicHamiltonian(str_to_symbolic(\"Z\"*(nqubits-1)+\"I\")).dense.matrix" + "Z_str = \"Z\"*nqubits\n", + "ZI_str = \"Z\"*(nqubits-1)+\"I\"\n", + "Z_op = SymbolicHamiltonian(str_to_symbolic(Z_str)).dense.matrix\n", + "ZI_op = SymbolicHamiltonian(str_to_symbolic(ZI_str)).dense.matrix\n", + "op_dict = {Z_str:Z_op, ZI_str: ZI_op}" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 47, "metadata": {}, "outputs": [], "source": [ "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator)\n", - "d = ZI_op\n", + "d_str = ZI_str\n", + "d = op_dict[d_str]\n", "# generate data for plotting sigma decrease of the first step\n", "s_space = np.linspace(1e-5, 0.6, 100)\n", "off_diagonal_norm_diff = []\n", @@ -175,9 +220,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 48, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "grid_search step: 0.30303525252525254 loss -6.165348149025746\n", + "hyperopt_search step: 0.565048795659714 loss -6.166892748979453\n", + "polynomial_approximation step: 0.040336885340305856 loss -6.149780650249902\n" + ] + } + ], "source": [ "# grid_search\n", "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.grid_search, step_max=0.6, d=d)\n", @@ -195,9 +250,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 49, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The minimum for cost function in the tested range is: 0.30303525252525254\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Plot the results\n", "plt.plot(s_space, off_diagonal_norm_diff)\n", @@ -208,7 +281,7 @@ "plt.axvline(x=step_poly, color='m', linestyle='-.',label='polynomial')\n", "plt.ylabel(r'$||\\sigma(H_0)||-\\sigma(H_k)||$')\n", "plt.xlabel('s')\n", - "plt.title('hyperopt first step')\n", + "plt.title(f'First DBI step with D={d_str}')\n", "plt.legend()\n", "print('The minimum for cost function in the tested range is:', step_grid)" ] @@ -229,9 +302,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 27, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "grid_search step: 0.04141414141414142\n", + "hyperopt_search step: 0.04175237619889543\n" + ] + } + ], "source": [ "search_range = 0.1\n", "if step_poly < search_range/2:\n", @@ -250,9 +332,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 50, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The minimum for cost function in the tested range is: 0.30303525252525254\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Plot the results\n", "plt.plot(s_space, off_diagonal_norm_diff)\n", @@ -261,7 +361,7 @@ "plt.axvline(x=step_poly, color='m', linestyle='-.',label='polynomial')\n", "plt.ylabel(r'$||\\sigma(H_0)||-\\sigma(H_k)||$')\n", "plt.xlabel('s')\n", - "plt.title('hyperopt first step')\n", + "plt.title(r'Restrict $s$ with polynomial')\n", "plt.legend()\n", "print('The minimum for cost function in the tested range is:', step_grid)" ] @@ -282,7 +382,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 29, "metadata": {}, "outputs": [], "source": [ @@ -292,9 +392,24 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 30, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.5|INFO|2024-03-01 13:32:30]: Using qibojit (numba) backend on /CPU:0\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initial off diagonal norm 15.16260860504813\n" + ] + } + ], "source": [ "# Hamiltonian\n", "set_backend(\"qibojit\", \"numba\")\n", @@ -308,9 +423,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 31, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + ] + } + ], "source": [ "generate_local_Z = generate_Z_operators(nqubits)\n", "Z_ops = list(generate_local_Z.values())\n", @@ -319,9 +456,51 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 32, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------Scheduling grid search----------\n", + "New optimized step at iteration 1/8: 0.11112 with operator IIZZ, loss 11.680408968308086\n", + "New optimized step at iteration 2/8: 0.08081727272727272 with operator IIZZ, loss 9.142367366920572\n", + "New optimized step at iteration 3/8: 0.1010190909090909 with operator ZZIZ, loss 7.958198114832907\n", + "New optimized step at iteration 4/8: 0.07071636363636363 with operator IIZZ, loss 6.482023887224007\n", + "New optimized step at iteration 5/8: 0.1010190909090909 with operator ZZIZ, loss 5.771042676877126\n", + "New optimized step at iteration 6/8: 0.08081727272727272 with operator IIZZ, loss 5.140994036668525\n", + "New optimized step at iteration 7/8: 0.11112 with operator -ZZII, loss 4.728283208000788\n", + "New optimized step at iteration 8/8: 0.06061545454545455 with operator IIZZ, loss 4.40400614947187\n", + "----------Scheduling hyperopt----------\n", + "New optimized step at iteration 1/8: 0.1088441936662135 with operator IIZZ, loss 11.676654434031814\n", + "New optimized step at iteration 2/8: 0.07922158082178958 with operator IIZZ, loss 9.135794848474623\n", + "New optimized step at iteration 3/8: 0.10296369768833129 with operator ZZIZ, loss 7.935942900247105\n" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[32], line 20\u001b[0m\n\u001b[1;32m 18\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m----------Scheduling \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mscheduling_labels[i]\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m----------\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m 19\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m _ \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(NSTEPS):\n\u001b[0;32m---> 20\u001b[0m dbi, idx, step, flip_sign \u001b[38;5;241m=\u001b[39m \u001b[43mselect_best_dbr_generator\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdbi\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mZ_ops\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mscheduling\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mscheduling\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcompare_canonical\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[1;32m 21\u001b[0m off_diagonal_norm_history\u001b[38;5;241m.\u001b[39mappend(dbi\u001b[38;5;241m.\u001b[39moff_diagonal_norm)\n\u001b[1;32m 22\u001b[0m steps\u001b[38;5;241m.\u001b[39mappend(steps[\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]\u001b[38;5;241m+\u001b[39mstep)\n", + "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/qibo/models/dbi/utils.py:105\u001b[0m, in \u001b[0;36mselect_best_dbr_generator\u001b[0;34m(dbi_object, d_list, step, compare_canonical, scheduling, **kwargs)\u001b[0m\n\u001b[1;32m 103\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m flip_list[i] \u001b[38;5;241m!=\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[1;32m 104\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m step \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 105\u001b[0m step_best \u001b[38;5;241m=\u001b[39m \u001b[43mdbi_eval\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mchoose_step\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 106\u001b[0m \u001b[43m \u001b[49m\u001b[43md\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mflip_list\u001b[49m\u001b[43m[\u001b[49m\u001b[43mi\u001b[49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[43md\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mscheduling\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mscheduling\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\n\u001b[1;32m 107\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 108\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 109\u001b[0m step_best \u001b[38;5;241m=\u001b[39m step\n", + "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/qibo/models/dbi/double_bracket.py:301\u001b[0m, in \u001b[0;36mDoubleBracketIteration.choose_step\u001b[0;34m(self, d, scheduling, backup_scheduling, **kwargs)\u001b[0m\n\u001b[1;32m 299\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mgrid_search_step(d\u001b[38;5;241m=\u001b[39md, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m 300\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m scheduling \u001b[38;5;129;01mis\u001b[39;00m DoubleBracketScheduling\u001b[38;5;241m.\u001b[39mhyperopt:\n\u001b[0;32m--> 301\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mhyperopt_step\u001b[49m\u001b[43m(\u001b[49m\u001b[43md\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43md\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 302\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m scheduling \u001b[38;5;129;01mis\u001b[39;00m DoubleBracketScheduling\u001b[38;5;241m.\u001b[39mpolynomial_approximation:\n\u001b[1;32m 303\u001b[0m step, coef \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mpolynomial_step(d\u001b[38;5;241m=\u001b[39md, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n", + "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/qibo/models/dbi/double_bracket.py:197\u001b[0m, in \u001b[0;36mDoubleBracketIteration.hyperopt_step\u001b[0;34m(self, step_min, step_max, max_evals, space, optimizer, look_ahead, verbose, d)\u001b[0m\n\u001b[1;32m 194\u001b[0m d \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdiagonal_h_matrix\n\u001b[1;32m 196\u001b[0m space \u001b[38;5;241m=\u001b[39m space(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mstep\u001b[39m\u001b[38;5;124m\"\u001b[39m, step_min, step_max)\n\u001b[0;32m--> 197\u001b[0m best \u001b[38;5;241m=\u001b[39m \u001b[43mhyperopt\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfmin\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 198\u001b[0m \u001b[43m \u001b[49m\u001b[43mfn\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpartial\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mloss\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43md\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43md\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlook_ahead\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mlook_ahead\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 199\u001b[0m \u001b[43m \u001b[49m\u001b[43mspace\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mspace\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 200\u001b[0m \u001b[43m \u001b[49m\u001b[43malgo\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moptimizer\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msuggest\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 201\u001b[0m \u001b[43m \u001b[49m\u001b[43mmax_evals\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmax_evals\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 202\u001b[0m \u001b[43m \u001b[49m\u001b[43mverbose\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mverbose\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 203\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 204\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m best[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mstep\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n", + "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/hyperopt/fmin.py:586\u001b[0m, in \u001b[0;36mfmin\u001b[0;34m(fn, space, algo, max_evals, timeout, loss_threshold, trials, rstate, allow_trials_fmin, pass_expr_memo_ctrl, catch_eval_exceptions, verbose, return_argmin, points_to_evaluate, max_queue_len, show_progressbar, early_stop_fn, trials_save_file)\u001b[0m\n\u001b[1;32m 583\u001b[0m rval\u001b[38;5;241m.\u001b[39mcatch_eval_exceptions \u001b[38;5;241m=\u001b[39m catch_eval_exceptions\n\u001b[1;32m 585\u001b[0m \u001b[38;5;66;03m# next line is where the fmin is actually executed\u001b[39;00m\n\u001b[0;32m--> 586\u001b[0m \u001b[43mrval\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mexhaust\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 588\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m return_argmin:\n\u001b[1;32m 589\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(trials\u001b[38;5;241m.\u001b[39mtrials) \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m:\n", + "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/hyperopt/fmin.py:364\u001b[0m, in \u001b[0;36mFMinIter.exhaust\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 362\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mexhaust\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[1;32m 363\u001b[0m n_done \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mlen\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtrials)\n\u001b[0;32m--> 364\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmax_evals\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mn_done\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mblock_until_done\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43masynchronous\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 365\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtrials\u001b[38;5;241m.\u001b[39mrefresh()\n\u001b[1;32m 366\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\n", + "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/hyperopt/fmin.py:278\u001b[0m, in \u001b[0;36mFMinIter.run\u001b[0;34m(self, N, block_until_done)\u001b[0m\n\u001b[1;32m 273\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtrials\u001b[38;5;241m.\u001b[39mrefresh()\n\u001b[1;32m 274\u001b[0m \u001b[38;5;66;03m# Based on existing trials and the domain, use `algo` to probe in\u001b[39;00m\n\u001b[1;32m 275\u001b[0m \u001b[38;5;66;03m# new hp points. Save the results of those inspections into\u001b[39;00m\n\u001b[1;32m 276\u001b[0m \u001b[38;5;66;03m# `new_trials`. This is the core of `run`, all the rest is just\u001b[39;00m\n\u001b[1;32m 277\u001b[0m \u001b[38;5;66;03m# processes orchestration\u001b[39;00m\n\u001b[0;32m--> 278\u001b[0m new_trials \u001b[38;5;241m=\u001b[39m \u001b[43malgo\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 279\u001b[0m \u001b[43m \u001b[49m\u001b[43mnew_ids\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdomain\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtrials\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrstate\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mintegers\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m31\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 280\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 281\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(new_ids) \u001b[38;5;241m>\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;28mlen\u001b[39m(new_trials)\n\u001b[1;32m 283\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(new_trials):\n", + "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/hyperopt/tpe.py:935\u001b[0m, in \u001b[0;36msuggest\u001b[0;34m(new_ids, domain, trials, seed, prior_weight, n_startup_jobs, n_EI_candidates, gamma, verbose)\u001b[0m\n\u001b[1;32m 931\u001b[0m memo[observed[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mvals\u001b[39m\u001b[38;5;124m\"\u001b[39m]] \u001b[38;5;241m=\u001b[39m observed_vals_dict\n\u001b[1;32m 933\u001b[0m \u001b[38;5;66;03m# evaluate `n_EI_candidates` pyll nodes in `posterior` using `memo`\u001b[39;00m\n\u001b[1;32m 934\u001b[0m \u001b[38;5;66;03m# TODO: it seems to return idxs, vals, all the same. Is this correct?\u001b[39;00m\n\u001b[0;32m--> 935\u001b[0m idxs, vals \u001b[38;5;241m=\u001b[39m \u001b[43mpyll\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrec_eval\u001b[49m\u001b[43m(\u001b[49m\u001b[43mposterior\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemo\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmemo\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mprint_node_on_error\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[1;32m 937\u001b[0m \u001b[38;5;66;03m# hack to add offset again for randint params\u001b[39;00m\n\u001b[1;32m 938\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m label, param \u001b[38;5;129;01min\u001b[39;00m domain\u001b[38;5;241m.\u001b[39mparams\u001b[38;5;241m.\u001b[39mitems():\n", + "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/hyperopt/pyll/base.py:902\u001b[0m, in \u001b[0;36mrec_eval\u001b[0;34m(expr, deepcopy_inputs, memo, max_program_len, memo_gc, print_trace, print_node_on_error)\u001b[0m\n\u001b[1;32m 899\u001b[0m kwargs \u001b[38;5;241m=\u001b[39m copy\u001b[38;5;241m.\u001b[39mdeepcopy(_kwargs)\n\u001b[1;32m 901\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 902\u001b[0m rval \u001b[38;5;241m=\u001b[39m \u001b[43mscope\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_impls\u001b[49m\u001b[43m[\u001b[49m\u001b[43mnode\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mname\u001b[49m\u001b[43m]\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 904\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m 905\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m print_node_on_error:\n", + "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/hyperopt/tpe.py:398\u001b[0m, in \u001b[0;36madaptive_parzen_normal\u001b[0;34m(mus, prior_weight, prior_mu, prior_sigma, LF)\u001b[0m\n\u001b[1;32m 394\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 395\u001b[0m \u001b[38;5;124;03mmus - matrix (N, M) of M, N-dimensional component centers\u001b[39;00m\n\u001b[1;32m 396\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 397\u001b[0m mus \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39marray(mus)\n\u001b[0;32m--> 398\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;28mstr\u001b[39m(mus\u001b[38;5;241m.\u001b[39mdtype) \u001b[38;5;241m!=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mobject\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 400\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m mus\u001b[38;5;241m.\u001b[39mndim \u001b[38;5;241m!=\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[1;32m 401\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmus must be vector\u001b[39m\u001b[38;5;124m\"\u001b[39m, mus)\n", + "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/numpy/core/_dtype.py:42\u001b[0m, in \u001b[0;36m__str__\u001b[0;34m(dtype)\u001b[0m\n\u001b[1;32m 40\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m dtype\u001b[38;5;241m.\u001b[39mstr\n\u001b[1;32m 41\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m---> 42\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mdtype\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mname\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/numpy/core/_dtype.py:363\u001b[0m, in \u001b[0;36m_name_get\u001b[0;34m(dtype)\u001b[0m\n\u001b[1;32m 361\u001b[0m \u001b[38;5;66;03m# append bit counts\u001b[39;00m\n\u001b[1;32m 362\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m _name_includes_bit_suffix(dtype):\n\u001b[0;32m--> 363\u001b[0m name \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;132;43;01m{}\u001b[39;49;00m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mformat\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdtype\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mitemsize\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m8\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 365\u001b[0m \u001b[38;5;66;03m# append metadata to datetimes\u001b[39;00m\n\u001b[1;32m 366\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m dtype\u001b[38;5;241m.\u001b[39mtype \u001b[38;5;129;01min\u001b[39;00m (np\u001b[38;5;241m.\u001b[39mdatetime64, np\u001b[38;5;241m.\u001b[39mtimedelta64):\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], "source": [ "NSTEPS = 8\n", "scheduling_list = [DoubleBracketScheduling.grid_search,\n", @@ -359,7 +538,28 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plt.figure()\n", "for i, scheduling in enumerate(scheduling_labels):\n", @@ -369,6 +569,100 @@ "plt.title(\"Compare Variational Pauli-Z using different scheduling strategies\")\n", "plt.legend()" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## When polynomial approximation has no solution\n", + "\n", + "In some cases, the prescribed taylor expansion order `n` may not be sufficient to produce a meaningful step duration (real positive). In these cases, we rely on a backup scheduling method in `choose_step`." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.5|INFO|2024-03-01 14:05:27]: Using qibojit (numba) backend on /CPU:0\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initial off diagonal norm 37.94733192202055\n" + ] + } + ], + "source": [ + "# Hamiltonian\n", + "set_backend(\"qibojit\", \"numba\")\n", + "\n", + "# hamiltonian parameters\n", + "nqubits = 5\n", + "h = 3\n", + "\n", + "# define the hamiltonian\n", + "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=h)\n", + "\n", + "# initialize class\n", + "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.canonical)\n", + "dbi.scheduling = DoubleBracketScheduling.polynomial_approximation\n", + "print(\"Initial off diagonal norm\", dbi.off_diagonal_norm)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For demonstration purposes, we let `n=1` which is a linear fit to the loss function. This results in no valid solutions and function `polynomial_step` returns `None`." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "None [(-1290240+0j), (-23040+0j)]\n" + ] + } + ], + "source": [ + "step, coef = dbi.polynomial_step(n=1)\n", + "print(step, coef)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "now n=2, step=0.03321888741718203\n", + "No solution found, going to backup DoubleBracketScheduling.grid_search\n", + "No solution found, going to backup DoubleBracketScheduling.hyperopt\n", + "0.03321888741718203 0.030312727272727272 0.029274407933556172\n" + ] + } + ], + "source": [ + "step_backup_poly = dbi.choose_step(backup_scheduling=DoubleBracketScheduling.polynomial_approximation, n=1, n_max=5)\n", + "step_backup_grid = dbi.choose_step(backup_scheduling=DoubleBracketScheduling.grid_search, n=1)\n", + "step_backup_hyper = dbi.choose_step(backup_scheduling=DoubleBracketScheduling.hyperopt, n=1)\n", + "print(step_backup_poly, step_backup_grid, step_backup_hyper)" + ] } ], "metadata": { diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index 2c160ea525..5c2e26f81c 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -156,14 +156,14 @@ def grid_search_step( d = self.diagonal_h_matrix loss_list = [self.loss(step, d=d) for step in space] - idx_max_loss = loss_list.index(min(loss_list)) + idx_max_loss = np.argmin(loss_list) return space[idx_max_loss] def hyperopt_step( self, step_min: float = 1e-5, step_max: float = 1, - max_evals: int = 1000, + max_evals: int = 500, space: callable = None, optimizer: callable = None, look_ahead: int = 1, @@ -205,7 +205,7 @@ def hyperopt_step( def polynomial_step( self, - n: int = 4, + n: int = 2, n_max: int = 5, d: np.array = None, backup_scheduling: DoubleBracketScheduling = None, @@ -226,6 +226,11 @@ def polynomial_step( if backup_scheduling is None: backup_scheduling = DoubleBracketScheduling.grid_search + if n > n_max: + raise ValueError( + "No solution can be found with polynomial approximation. Increase `n_max` or use other scheduling methods." + ) + def sigma(h: np.array): return h - self.backend.cast(np.diag(np.diag(self.backend.to_numpy(h)))) @@ -259,7 +264,9 @@ def Gamma(k: int): power = k + j product_matrix = c1[k] @ c2[j] trace_coefficients[power] += 2 * np.trace(product_matrix) - roots = np.roots(list(reversed(trace_coefficients[: n + 1]))) + # coefficients from high to low (n:0) + coef = list(reversed(trace_coefficients[: n + 1])) + roots = np.roots(coef) error = 1e-3 real_positive_roots = [ np.real(root) @@ -268,22 +275,29 @@ def Gamma(k: int): ] # solution exists, return minimum s if len(real_positive_roots) > 0: - return min(real_positive_roots) - # solution does not exist, resort to backup scheduling - elif ( - backup_scheduling == DoubleBracketScheduling.polynomial_approximation - and n < n_max + 1 - ): - return self.polynomial_step( - n=n + 1, d=d, backup_scheduling=backup_scheduling - ) + return min(real_positive_roots), coef + # solution does not exist, return None else: - return self.choose_step(d=d, scheduling=backup_scheduling) + return None, coef + + # # solution does not exist, resort to backup scheduling + # elif ( + # backup_scheduling == DoubleBracketScheduling.polynomial_approximation + # and n < n_max + 1 + # ): + # return self.polynomial_step( + # n=n + 1, d=d, backup_scheduling=backup_scheduling + # ) + # else: + # return self.choose_step(d=d, scheduling=backup_scheduling) def choose_step( self, d: Optional[np.array] = None, scheduling: Optional[DoubleBracketScheduling] = None, + backup_scheduling: Optional[ + DoubleBracketScheduling + ] = DoubleBracketScheduling.hyperopt, **kwargs, ): if scheduling is None: @@ -293,7 +307,23 @@ def choose_step( if scheduling is DoubleBracketScheduling.hyperopt: return self.hyperopt_step(d=d, **kwargs) if scheduling is DoubleBracketScheduling.polynomial_approximation: - return self.polynomial_step(d=d, **kwargs) + step, coef = self.polynomial_step(d=d, **kwargs) + # if no solution + if step is None: + if ( + backup_scheduling + == DoubleBracketScheduling.polynomial_approximation + and coef is not None + ): + # if `n` is not provided, try default value + kwargs["n"] = kwargs.get("n", 2) + kwargs["n"] += 1 + step, coef = self.polynomial_step(d=d, **kwargs) + # if n==n_max, return None + else: + # Issue: cannot pass kwargs + step = self.choose_step(d=d, scheduling=backup_scheduling) + return step def loss(self, step: float, d: np.array = None, look_ahead: int = 1): """ From 54a86a8add3bafedeb0383b92b346296db16aa1b Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi <146689118+Sam-XiaoyueLi@users.noreply.github.com> Date: Fri, 1 Mar 2024 14:30:54 +0800 Subject: [PATCH 12/22] Update src/qibo/models/dbi/double_bracket.py Co-authored-by: Edoardo Pedicillo --- src/qibo/models/dbi/double_bracket.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index 5c2e26f81c..2fe515306d 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -223,8 +223,6 @@ def polynomial_step( if d is None: d = self.diagonal_h_matrix - if backup_scheduling is None: - backup_scheduling = DoubleBracketScheduling.grid_search if n > n_max: raise ValueError( From 50554e32a7ce8a6f8264af48aad8e9c2c267b9a2 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Fri, 1 Mar 2024 22:43:50 +0800 Subject: [PATCH 13/22] Simplify code structure in `polynomial_step` --- examples/dbi/dbi_scheduling.ipynb | 309 +++----------------------- src/qibo/models/dbi/double_bracket.py | 46 +--- 2 files changed, 46 insertions(+), 309 deletions(-) diff --git a/examples/dbi/dbi_scheduling.ipynb b/examples/dbi/dbi_scheduling.ipynb index 686156fa4c..3958aa2dff 100644 --- a/examples/dbi/dbi_scheduling.ipynb +++ b/examples/dbi/dbi_scheduling.ipynb @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -42,24 +42,9 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.5|INFO|2024-03-01 14:04:46]: Using qibojit (numba) backend on /CPU:0\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Initial off diagonal norm 37.94733192202055\n" - ] - } - ], + "outputs": [], "source": [ "# Hamiltonian\n", "set_backend(\"qibojit\", \"numba\")\n", @@ -85,7 +70,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -108,19 +93,9 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "grid_search step: 0.030312727272727272\n", - "hyperopt_search step: 0.029554880094525483\n", - "polynomial_approximation step: 0.032960905003724034\n" - ] - } - ], + "outputs": [], "source": [ "# grid_search\n", "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.grid_search)\n", @@ -134,27 +109,9 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The minimum for cost function in the tested range is: 0.030312727272727272\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Plot the results\n", "plt.plot(s_space, off_diagonal_norm_diff)\n", @@ -179,18 +136,9 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.5|WARNING|2024-03-01 13:36:46]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-01 13:36:46]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" - ] - } - ], + "outputs": [], "source": [ "# Generate the digaonal operators\n", "Z_str = \"Z\"*nqubits\n", @@ -202,7 +150,7 @@ }, { "cell_type": "code", - "execution_count": 47, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -220,19 +168,9 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "grid_search step: 0.30303525252525254 loss -6.165348149025746\n", - "hyperopt_search step: 0.565048795659714 loss -6.166892748979453\n", - "polynomial_approximation step: 0.040336885340305856 loss -6.149780650249902\n" - ] - } - ], + "outputs": [], "source": [ "# grid_search\n", "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.grid_search, step_max=0.6, d=d)\n", @@ -250,27 +188,9 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The minimum for cost function in the tested range is: 0.30303525252525254\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Plot the results\n", "plt.plot(s_space, off_diagonal_norm_diff)\n", @@ -302,18 +222,9 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "grid_search step: 0.04141414141414142\n", - "hyperopt_search step: 0.04175237619889543\n" - ] - } - ], + "outputs": [], "source": [ "search_range = 0.1\n", "if step_poly < search_range/2:\n", @@ -332,27 +243,9 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The minimum for cost function in the tested range is: 0.30303525252525254\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Plot the results\n", "plt.plot(s_space, off_diagonal_norm_diff)\n", @@ -382,7 +275,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -392,24 +285,9 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.5|INFO|2024-03-01 13:32:30]: Using qibojit (numba) backend on /CPU:0\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Initial off diagonal norm 15.16260860504813\n" - ] - } - ], + "outputs": [], "source": [ "# Hamiltonian\n", "set_backend(\"qibojit\", \"numba\")\n", @@ -423,31 +301,9 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-01 13:32:30]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" - ] - } - ], + "outputs": [], "source": [ "generate_local_Z = generate_Z_operators(nqubits)\n", "Z_ops = list(generate_local_Z.values())\n", @@ -456,51 +312,9 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "----------Scheduling grid search----------\n", - "New optimized step at iteration 1/8: 0.11112 with operator IIZZ, loss 11.680408968308086\n", - "New optimized step at iteration 2/8: 0.08081727272727272 with operator IIZZ, loss 9.142367366920572\n", - "New optimized step at iteration 3/8: 0.1010190909090909 with operator ZZIZ, loss 7.958198114832907\n", - "New optimized step at iteration 4/8: 0.07071636363636363 with operator IIZZ, loss 6.482023887224007\n", - "New optimized step at iteration 5/8: 0.1010190909090909 with operator ZZIZ, loss 5.771042676877126\n", - "New optimized step at iteration 6/8: 0.08081727272727272 with operator IIZZ, loss 5.140994036668525\n", - "New optimized step at iteration 7/8: 0.11112 with operator -ZZII, loss 4.728283208000788\n", - "New optimized step at iteration 8/8: 0.06061545454545455 with operator IIZZ, loss 4.40400614947187\n", - "----------Scheduling hyperopt----------\n", - "New optimized step at iteration 1/8: 0.1088441936662135 with operator IIZZ, loss 11.676654434031814\n", - "New optimized step at iteration 2/8: 0.07922158082178958 with operator IIZZ, loss 9.135794848474623\n", - "New optimized step at iteration 3/8: 0.10296369768833129 with operator ZZIZ, loss 7.935942900247105\n" - ] - }, - { - "ename": "KeyboardInterrupt", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[32], line 20\u001b[0m\n\u001b[1;32m 18\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m----------Scheduling \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mscheduling_labels[i]\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m----------\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m 19\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m _ \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(NSTEPS):\n\u001b[0;32m---> 20\u001b[0m dbi, idx, step, flip_sign \u001b[38;5;241m=\u001b[39m \u001b[43mselect_best_dbr_generator\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdbi\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mZ_ops\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mscheduling\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mscheduling\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcompare_canonical\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[1;32m 21\u001b[0m off_diagonal_norm_history\u001b[38;5;241m.\u001b[39mappend(dbi\u001b[38;5;241m.\u001b[39moff_diagonal_norm)\n\u001b[1;32m 22\u001b[0m steps\u001b[38;5;241m.\u001b[39mappend(steps[\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]\u001b[38;5;241m+\u001b[39mstep)\n", - "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/qibo/models/dbi/utils.py:105\u001b[0m, in \u001b[0;36mselect_best_dbr_generator\u001b[0;34m(dbi_object, d_list, step, compare_canonical, scheduling, **kwargs)\u001b[0m\n\u001b[1;32m 103\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m flip_list[i] \u001b[38;5;241m!=\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[1;32m 104\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m step \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 105\u001b[0m step_best \u001b[38;5;241m=\u001b[39m \u001b[43mdbi_eval\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mchoose_step\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 106\u001b[0m \u001b[43m \u001b[49m\u001b[43md\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mflip_list\u001b[49m\u001b[43m[\u001b[49m\u001b[43mi\u001b[49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[43md\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mscheduling\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mscheduling\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\n\u001b[1;32m 107\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 108\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 109\u001b[0m step_best \u001b[38;5;241m=\u001b[39m step\n", - "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/qibo/models/dbi/double_bracket.py:301\u001b[0m, in \u001b[0;36mDoubleBracketIteration.choose_step\u001b[0;34m(self, d, scheduling, backup_scheduling, **kwargs)\u001b[0m\n\u001b[1;32m 299\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mgrid_search_step(d\u001b[38;5;241m=\u001b[39md, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m 300\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m scheduling \u001b[38;5;129;01mis\u001b[39;00m DoubleBracketScheduling\u001b[38;5;241m.\u001b[39mhyperopt:\n\u001b[0;32m--> 301\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mhyperopt_step\u001b[49m\u001b[43m(\u001b[49m\u001b[43md\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43md\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 302\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m scheduling \u001b[38;5;129;01mis\u001b[39;00m DoubleBracketScheduling\u001b[38;5;241m.\u001b[39mpolynomial_approximation:\n\u001b[1;32m 303\u001b[0m step, coef \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mpolynomial_step(d\u001b[38;5;241m=\u001b[39md, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n", - "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/qibo/models/dbi/double_bracket.py:197\u001b[0m, in \u001b[0;36mDoubleBracketIteration.hyperopt_step\u001b[0;34m(self, step_min, step_max, max_evals, space, optimizer, look_ahead, verbose, d)\u001b[0m\n\u001b[1;32m 194\u001b[0m d \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdiagonal_h_matrix\n\u001b[1;32m 196\u001b[0m space \u001b[38;5;241m=\u001b[39m space(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mstep\u001b[39m\u001b[38;5;124m\"\u001b[39m, step_min, step_max)\n\u001b[0;32m--> 197\u001b[0m best \u001b[38;5;241m=\u001b[39m \u001b[43mhyperopt\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfmin\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 198\u001b[0m \u001b[43m \u001b[49m\u001b[43mfn\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpartial\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mloss\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43md\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43md\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlook_ahead\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mlook_ahead\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 199\u001b[0m \u001b[43m \u001b[49m\u001b[43mspace\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mspace\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 200\u001b[0m \u001b[43m \u001b[49m\u001b[43malgo\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moptimizer\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msuggest\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 201\u001b[0m \u001b[43m \u001b[49m\u001b[43mmax_evals\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmax_evals\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 202\u001b[0m \u001b[43m \u001b[49m\u001b[43mverbose\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mverbose\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 203\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 204\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m best[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mstep\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n", - "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/hyperopt/fmin.py:586\u001b[0m, in \u001b[0;36mfmin\u001b[0;34m(fn, space, algo, max_evals, timeout, loss_threshold, trials, rstate, allow_trials_fmin, pass_expr_memo_ctrl, catch_eval_exceptions, verbose, return_argmin, points_to_evaluate, max_queue_len, show_progressbar, early_stop_fn, trials_save_file)\u001b[0m\n\u001b[1;32m 583\u001b[0m rval\u001b[38;5;241m.\u001b[39mcatch_eval_exceptions \u001b[38;5;241m=\u001b[39m catch_eval_exceptions\n\u001b[1;32m 585\u001b[0m \u001b[38;5;66;03m# next line is where the fmin is actually executed\u001b[39;00m\n\u001b[0;32m--> 586\u001b[0m \u001b[43mrval\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mexhaust\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 588\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m return_argmin:\n\u001b[1;32m 589\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(trials\u001b[38;5;241m.\u001b[39mtrials) \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m:\n", - "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/hyperopt/fmin.py:364\u001b[0m, in \u001b[0;36mFMinIter.exhaust\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 362\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mexhaust\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[1;32m 363\u001b[0m n_done \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mlen\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtrials)\n\u001b[0;32m--> 364\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmax_evals\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mn_done\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mblock_until_done\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43masynchronous\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 365\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtrials\u001b[38;5;241m.\u001b[39mrefresh()\n\u001b[1;32m 366\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\n", - "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/hyperopt/fmin.py:278\u001b[0m, in \u001b[0;36mFMinIter.run\u001b[0;34m(self, N, block_until_done)\u001b[0m\n\u001b[1;32m 273\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtrials\u001b[38;5;241m.\u001b[39mrefresh()\n\u001b[1;32m 274\u001b[0m \u001b[38;5;66;03m# Based on existing trials and the domain, use `algo` to probe in\u001b[39;00m\n\u001b[1;32m 275\u001b[0m \u001b[38;5;66;03m# new hp points. Save the results of those inspections into\u001b[39;00m\n\u001b[1;32m 276\u001b[0m \u001b[38;5;66;03m# `new_trials`. This is the core of `run`, all the rest is just\u001b[39;00m\n\u001b[1;32m 277\u001b[0m \u001b[38;5;66;03m# processes orchestration\u001b[39;00m\n\u001b[0;32m--> 278\u001b[0m new_trials \u001b[38;5;241m=\u001b[39m \u001b[43malgo\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 279\u001b[0m \u001b[43m \u001b[49m\u001b[43mnew_ids\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdomain\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtrials\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrstate\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mintegers\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m31\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 280\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 281\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(new_ids) \u001b[38;5;241m>\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;28mlen\u001b[39m(new_trials)\n\u001b[1;32m 283\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(new_trials):\n", - "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/hyperopt/tpe.py:935\u001b[0m, in \u001b[0;36msuggest\u001b[0;34m(new_ids, domain, trials, seed, prior_weight, n_startup_jobs, n_EI_candidates, gamma, verbose)\u001b[0m\n\u001b[1;32m 931\u001b[0m memo[observed[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mvals\u001b[39m\u001b[38;5;124m\"\u001b[39m]] \u001b[38;5;241m=\u001b[39m observed_vals_dict\n\u001b[1;32m 933\u001b[0m \u001b[38;5;66;03m# evaluate `n_EI_candidates` pyll nodes in `posterior` using `memo`\u001b[39;00m\n\u001b[1;32m 934\u001b[0m \u001b[38;5;66;03m# TODO: it seems to return idxs, vals, all the same. Is this correct?\u001b[39;00m\n\u001b[0;32m--> 935\u001b[0m idxs, vals \u001b[38;5;241m=\u001b[39m \u001b[43mpyll\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrec_eval\u001b[49m\u001b[43m(\u001b[49m\u001b[43mposterior\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemo\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmemo\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mprint_node_on_error\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[1;32m 937\u001b[0m \u001b[38;5;66;03m# hack to add offset again for randint params\u001b[39;00m\n\u001b[1;32m 938\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m label, param \u001b[38;5;129;01min\u001b[39;00m domain\u001b[38;5;241m.\u001b[39mparams\u001b[38;5;241m.\u001b[39mitems():\n", - "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/hyperopt/pyll/base.py:902\u001b[0m, in \u001b[0;36mrec_eval\u001b[0;34m(expr, deepcopy_inputs, memo, max_program_len, memo_gc, print_trace, print_node_on_error)\u001b[0m\n\u001b[1;32m 899\u001b[0m kwargs \u001b[38;5;241m=\u001b[39m copy\u001b[38;5;241m.\u001b[39mdeepcopy(_kwargs)\n\u001b[1;32m 901\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 902\u001b[0m rval \u001b[38;5;241m=\u001b[39m \u001b[43mscope\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_impls\u001b[49m\u001b[43m[\u001b[49m\u001b[43mnode\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mname\u001b[49m\u001b[43m]\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 904\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m 905\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m print_node_on_error:\n", - "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/hyperopt/tpe.py:398\u001b[0m, in \u001b[0;36madaptive_parzen_normal\u001b[0;34m(mus, prior_weight, prior_mu, prior_sigma, LF)\u001b[0m\n\u001b[1;32m 394\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 395\u001b[0m \u001b[38;5;124;03mmus - matrix (N, M) of M, N-dimensional component centers\u001b[39;00m\n\u001b[1;32m 396\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 397\u001b[0m mus \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39marray(mus)\n\u001b[0;32m--> 398\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;28mstr\u001b[39m(mus\u001b[38;5;241m.\u001b[39mdtype) \u001b[38;5;241m!=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mobject\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 400\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m mus\u001b[38;5;241m.\u001b[39mndim \u001b[38;5;241m!=\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[1;32m 401\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmus must be vector\u001b[39m\u001b[38;5;124m\"\u001b[39m, mus)\n", - "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/numpy/core/_dtype.py:42\u001b[0m, in \u001b[0;36m__str__\u001b[0;34m(dtype)\u001b[0m\n\u001b[1;32m 40\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m dtype\u001b[38;5;241m.\u001b[39mstr\n\u001b[1;32m 41\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m---> 42\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mdtype\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mname\u001b[49m\n", - "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/numpy/core/_dtype.py:363\u001b[0m, in \u001b[0;36m_name_get\u001b[0;34m(dtype)\u001b[0m\n\u001b[1;32m 361\u001b[0m \u001b[38;5;66;03m# append bit counts\u001b[39;00m\n\u001b[1;32m 362\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m _name_includes_bit_suffix(dtype):\n\u001b[0;32m--> 363\u001b[0m name \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;132;43;01m{}\u001b[39;49;00m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mformat\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdtype\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mitemsize\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m8\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 365\u001b[0m \u001b[38;5;66;03m# append metadata to datetimes\u001b[39;00m\n\u001b[1;32m 366\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m dtype\u001b[38;5;241m.\u001b[39mtype \u001b[38;5;129;01min\u001b[39;00m (np\u001b[38;5;241m.\u001b[39mdatetime64, np\u001b[38;5;241m.\u001b[39mtimedelta64):\n", - "\u001b[0;31mKeyboardInterrupt\u001b[0m: " - ] - } - ], + "outputs": [], "source": [ "NSTEPS = 8\n", "scheduling_list = [DoubleBracketScheduling.grid_search,\n", @@ -538,33 +352,12 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plt.figure()\n", "for i, scheduling in enumerate(scheduling_labels):\n", " plt.plot(s_scheduling[i], off_norm_scheduling[i], '-o', label=scheduling)\n", - "plt.xlabel(\"Iterations\")\n", + "plt.xlabel(\"Step durations\")\n", "plt.ylabel(\"Norm off-diagonal restriction\")\n", "plt.title(\"Compare Variational Pauli-Z using different scheduling strategies\")\n", "plt.legend()" @@ -581,24 +374,9 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.5|INFO|2024-03-01 14:05:27]: Using qibojit (numba) backend on /CPU:0\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Initial off diagonal norm 37.94733192202055\n" - ] - } - ], + "outputs": [], "source": [ "# Hamiltonian\n", "set_backend(\"qibojit\", \"numba\")\n", @@ -625,17 +403,9 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "None [(-1290240+0j), (-23040+0j)]\n" - ] - } - ], + "outputs": [], "source": [ "step, coef = dbi.polynomial_step(n=1)\n", "print(step, coef)" @@ -643,20 +413,9 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "now n=2, step=0.03321888741718203\n", - "No solution found, going to backup DoubleBracketScheduling.grid_search\n", - "No solution found, going to backup DoubleBracketScheduling.hyperopt\n", - "0.03321888741718203 0.030312727272727272 0.029274407933556172\n" - ] - } - ], + "outputs": [], "source": [ "step_backup_poly = dbi.choose_step(backup_scheduling=DoubleBracketScheduling.polynomial_approximation, n=1, n_max=5)\n", "step_backup_grid = dbi.choose_step(backup_scheduling=DoubleBracketScheduling.grid_search, n=1)\n", diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index 2fe515306d..ddd7e179b9 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -9,6 +9,8 @@ from qibo.hamiltonians import Hamiltonian +error = 1e-3 + class DoubleBracketGeneratorType(Enum): """Define DBF evolution.""" @@ -223,7 +225,6 @@ def polynomial_step( if d is None: d = self.diagonal_h_matrix - if n > n_max: raise ValueError( "No solution can be found with polynomial approximation. Increase `n_max` or use other scheduling methods." @@ -232,29 +233,18 @@ def polynomial_step( def sigma(h: np.array): return h - self.backend.cast(np.diag(np.diag(self.backend.to_numpy(h)))) - def Gamma(k: int): - r"""Computes the k_th Gamma function i.e $\Gamma_k=[W,...,[W,[W,H]]...]$, where we take k nested commutators with $W = [D, H]$""" - if k == 0: - return self.h.matrix - else: - W = self.commutator(d, sigma(self.h.matrix)) - result = self.h.matrix - for _ in range(k): - result = self.commutator(W, result) - return result - - # list starting from s^n highest order to s^0 - sigma_gamma_list = np.array([sigma(Gamma(k)) for k in range(n + 2)]) + # generate Gamma's where $\Gamma_{k+1}=[W, \Gamma_{k}], $\Gamma_0=H + W = self.commutator(d, sigma(self.h.matrix)) + Gamma_list = [self.h.matrix] + sigma_Gamma_list = [sigma(Gamma_list[0])] + for _ in range(n + 1): + Gamma_list.append(self.commutator(W, Gamma_list[-1])) + sigma_Gamma_list.append(sigma(Gamma_list[-1])) + sigma_Gamma_list = np.array(sigma_Gamma_list) exp_list = np.array([1 / math.factorial(k) for k in range(n + 1)]) # coefficients for rotation with [W,H] and H - c1 = [ - exp_coef * delta_gamma - for exp_coef, delta_gamma in zip(exp_list, sigma_gamma_list[1:]) - ] - c2 = [ - exp_coef * delta_gamma - for exp_coef, delta_gamma in zip(exp_list, sigma_gamma_list[:-1]) - ] + c1 = exp_list.reshape(-1, 1, 1) * sigma_Gamma_list[1:] + c2 = exp_list.reshape(-1, 1, 1) * sigma_Gamma_list[:-1] # product coefficient trace_coefficients = [0] * (2 * n + 1) for k in range(n + 1): @@ -265,7 +255,6 @@ def Gamma(k: int): # coefficients from high to low (n:0) coef = list(reversed(trace_coefficients[: n + 1])) roots = np.roots(coef) - error = 1e-3 real_positive_roots = [ np.real(root) for root in roots @@ -278,17 +267,6 @@ def Gamma(k: int): else: return None, coef - # # solution does not exist, resort to backup scheduling - # elif ( - # backup_scheduling == DoubleBracketScheduling.polynomial_approximation - # and n < n_max + 1 - # ): - # return self.polynomial_step( - # n=n + 1, d=d, backup_scheduling=backup_scheduling - # ) - # else: - # return self.choose_step(d=d, scheduling=backup_scheduling) - def choose_step( self, d: Optional[np.array] = None, From 4fcdf643171760f2f3d4df7794b20992e906bdb1 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Fri, 1 Mar 2024 22:49:51 +0800 Subject: [PATCH 14/22] Update `test_models_dbi.py` --- tests/test_models_dbi.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/tests/test_models_dbi.py b/tests/test_models_dbi.py index a573c32088..111079f8a7 100644 --- a/tests/test_models_dbi.py +++ b/tests/test_models_dbi.py @@ -150,10 +150,10 @@ def test_double_bracket_iteration_scheduling_polynomial( ) initial_off_diagonal_norm = dbi.off_diagonal_norm for _ in range(NSTEPS): - step1 = dbi.polynomial_step(n=n, d=d, backup_scheduling=backup_scheduling) + step1 = dbi.choose_step(n=n, backup_scheduling=backup_scheduling) dbi(d=d, step=step1) - step2 = dbi.choose_step( - scheduling=DoubleBracketScheduling.polynomial_approximation, n=n - ) - dbi(step=step2) + # step2 = dbi.choose_step( + # scheduling=DoubleBracketScheduling.polynomial_approximation, n=n + # ) + # dbi(step=step2) assert initial_off_diagonal_norm > dbi.off_diagonal_norm From 67701e173c03d09df60080948fb6ae4513486c1f Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Fri, 1 Mar 2024 23:29:59 +0800 Subject: [PATCH 15/22] Define sigma and Gamma as class function --- src/qibo/models/dbi/double_bracket.py | 24 ++++++++++++++---------- 1 file changed, 14 insertions(+), 10 deletions(-) diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index ddd7e179b9..ffd371110c 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -230,17 +230,10 @@ def polynomial_step( "No solution can be found with polynomial approximation. Increase `n_max` or use other scheduling methods." ) - def sigma(h: np.array): - return h - self.backend.cast(np.diag(np.diag(self.backend.to_numpy(h)))) - # generate Gamma's where $\Gamma_{k+1}=[W, \Gamma_{k}], $\Gamma_0=H - W = self.commutator(d, sigma(self.h.matrix)) - Gamma_list = [self.h.matrix] - sigma_Gamma_list = [sigma(Gamma_list[0])] - for _ in range(n + 1): - Gamma_list.append(self.commutator(W, Gamma_list[-1])) - sigma_Gamma_list.append(sigma(Gamma_list[-1])) - sigma_Gamma_list = np.array(sigma_Gamma_list) + W = self.commutator(d, self.sigma(self.h.matrix)) + Gamma_list = self.generate_Gamma_list(n + 2, d) + sigma_Gamma_list = list(map(self.sigma, Gamma_list)) exp_list = np.array([1 / math.factorial(k) for k in range(n + 1)]) # coefficients for rotation with [W,H] and H c1 = exp_list.reshape(-1, 1, 1) * sigma_Gamma_list[1:] @@ -337,3 +330,14 @@ def energy_fluctuation(self, state): state (np.ndarray): quantum state to be used to compute the energy fluctuation with H. """ return self.h.energy_fluctuation(state) + + def sigma(self, h: np.array): + return h - self.backend.cast(np.diag(np.diag(self.backend.to_numpy(h)))) + + def generate_Gamma_list(self, n: int, d: np.array): + r"""Computes the n-nested Gamma functions, where $\Gamma_k=[W,...,[W,[W,H]]...]$, where we take k nested commutators with $W = [D, H]$""" + W = self.commutator(d, self.sigma(self.h.matrix)) + Gamma_list = [self.h.matrix] + for _ in range(n - 1): + Gamma_list.append(self.commutator(W, Gamma_list[-1])) + return Gamma_list From ca71ffaa76980a2142c37d3d60c4816a3ae60982 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Tue, 5 Mar 2024 15:12:12 +0800 Subject: [PATCH 16/22] Modified structure: moving scheduling strategies in `utils_scheduling.py` --- examples/dbi/dbi_scheduling.ipynb | 303 +++++++++++++++++++++--- src/qibo/models/dbi/double_bracket.py | 185 +++------------ src/qibo/models/dbi/utils.py | 26 +- src/qibo/models/dbi/utils_scheduling.py | 145 ++++++++++++ 4 files changed, 464 insertions(+), 195 deletions(-) create mode 100644 src/qibo/models/dbi/utils_scheduling.py diff --git a/examples/dbi/dbi_scheduling.ipynb b/examples/dbi/dbi_scheduling.ipynb index 3958aa2dff..34a49760b5 100644 --- a/examples/dbi/dbi_scheduling.ipynb +++ b/examples/dbi/dbi_scheduling.ipynb @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -29,7 +29,8 @@ "\n", "from qibo import hamiltonians, set_backend\n", "from qibo.models.dbi.double_bracket import DoubleBracketGeneratorType, DoubleBracketScheduling, DoubleBracketIteration\n", - "from qibo.models.dbi.utils import *" + "from qibo.models.dbi.utils import *\n", + "from qibo.models.dbi.utils_scheduling import *" ] }, { @@ -42,9 +43,25 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "OMP: Info #276: omp_set_nested routine deprecated, please use omp_set_max_active_levels instead.\n", + "[Qibo 0.2.5|INFO|2024-03-05 15:06:24]: Using qibojit (numba) backend on /CPU:0\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initial off diagonal norm 37.94733192202055\n" + ] + } + ], "source": [ "# Hamiltonian\n", "set_backend(\"qibojit\", \"numba\")\n", @@ -70,7 +87,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -93,9 +110,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "grid_search step: 0.030312727272727272\n", + "hyperopt_search step: 0.028991467713834373\n", + "polynomial_approximation step: 0.032960905003724034\n" + ] + } + ], "source": [ "# grid_search\n", "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.grid_search)\n", @@ -109,9 +136,34 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The minimum for cost function in the tested range is:" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 0.030312727272727272\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Plot the results\n", "plt.plot(s_space, off_diagonal_norm_diff)\n", @@ -136,9 +188,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.5|WARNING|2024-03-05 15:06:24]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-05 15:06:24]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + ] + } + ], "source": [ "# Generate the digaonal operators\n", "Z_str = \"Z\"*nqubits\n", @@ -150,7 +211,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -168,9 +229,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "grid_search step: 0.30303525252525254 loss -6.165348149025746\n", + "hyperopt_search step: 0.30457003862873383 loss -6.158069649792722\n", + "polynomial_approximation step: 0.040336885340305856 loss -6.149780650249902\n" + ] + } + ], "source": [ "# grid_search\n", "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.grid_search, step_max=0.6, d=d)\n", @@ -188,9 +259,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The minimum for cost function in the tested range is: 0.30303525252525254\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Plot the results\n", "plt.plot(s_space, off_diagonal_norm_diff)\n", @@ -222,9 +311,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "grid_search step: 0.04141414141414142\n", + "hyperopt_search step: 0.041686777442654525\n" + ] + } + ], "source": [ "search_range = 0.1\n", "if step_poly < search_range/2:\n", @@ -243,9 +341,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The minimum for cost function in the tested range is: 0.04141414141414142\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Plot the results\n", "plt.plot(s_space, off_diagonal_norm_diff)\n", @@ -275,7 +391,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -285,9 +401,24 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.5|INFO|2024-03-05 15:06:25]: Using qibojit (numba) backend on /CPU:0\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initial off diagonal norm 15.582565474255802\n" + ] + } + ], "source": [ "# Hamiltonian\n", "set_backend(\"qibojit\", \"numba\")\n", @@ -301,9 +432,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", + "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" + ] + } + ], "source": [ "generate_local_Z = generate_Z_operators(nqubits)\n", "Z_ops = list(generate_local_Z.values())\n", @@ -312,9 +465,48 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------Scheduling grid search----------\n", + "New optimized step at iteration 1/8: 0.09091818181818181 with operator -IIIZ, loss 12.06390502880173\n", + "New optimized step at iteration 2/8: 0.08081727272727272 with operator -IIIZ, loss 9.635355222386766\n", + "New optimized step at iteration 3/8: 0.09091818181818181 with operator ZZII, loss 8.551120821934958\n", + "New optimized step at iteration 4/8: 0.06061545454545455 with operator -IIIZ, loss 7.454888988134408\n", + "New optimized step at iteration 5/8: 0.09091818181818181 with operator ZZII, loss 6.526038310796992\n", + "New optimized step at iteration 6/8: 0.07071636363636363 with operator -IIIZ, loss 5.906198775254362\n", + "New optimized step at iteration 7/8: 0.07071636363636363 with operator -IIIZ, loss 5.558604782647778\n", + "New optimized step at iteration 8/8: 0.09091818181818181 with operator IIZI, loss 5.248002043412237\n", + "----------Scheduling hyperopt----------\n", + "New optimized step at iteration 1/8: 0.0952680083828445 with operator -IIIZ, loss 12.048611508414254\n", + "New optimized step at iteration 2/8: 0.0759399266935567 with operator -IIIZ, loss 9.647010146511933\n", + "New optimized step at iteration 3/8: 0.0953305046594857 with operator ZZII, loss 8.545812587336131\n", + "New optimized step at iteration 4/8: 0.0638318397684811 with operator -IIIZ, loss 7.391689830573071\n", + "New optimized step at iteration 5/8: 0.0857170843370093 with operator ZZII, loss 6.534188669695426\n", + "New optimized step at iteration 6/8: 0.06796907471647104 with operator -IIIZ, loss 5.930126378868041\n", + "New optimized step at iteration 7/8: 0.06714742808838461 with operator -IIIZ, loss 5.582951426889378\n", + "New optimized step at iteration 8/8: 0.10283381512622272 with operator IIZI, loss 5.253925034956114\n", + "----------Scheduling polynomial----------\n" + ] + }, + { + "ename": "TypeError", + "evalue": "unsupported operand type(s) for *: 'complex' and 'NoneType'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[15], line 20\u001b[0m\n\u001b[1;32m 18\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m----------Scheduling \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mscheduling_labels[i]\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m----------\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m 19\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m _ \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(NSTEPS):\n\u001b[0;32m---> 20\u001b[0m dbi, idx, step, flip_sign \u001b[38;5;241m=\u001b[39m \u001b[43mselect_best_dbr_generator\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdbi\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mZ_ops\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mscheduling\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mscheduling\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcompare_canonical\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[1;32m 21\u001b[0m off_diagonal_norm_history\u001b[38;5;241m.\u001b[39mappend(dbi\u001b[38;5;241m.\u001b[39moff_diagonal_norm)\n\u001b[1;32m 22\u001b[0m steps\u001b[38;5;241m.\u001b[39mappend(steps[\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]\u001b[38;5;241m+\u001b[39mstep)\n", + "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/qibo/models/dbi/utils.py:111\u001b[0m, in \u001b[0;36mselect_best_dbr_generator\u001b[0;34m(dbi_object, d_list, step, compare_canonical, scheduling, **kwargs)\u001b[0m\n\u001b[1;32m 109\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 110\u001b[0m step_best \u001b[38;5;241m=\u001b[39m step\n\u001b[0;32m--> 111\u001b[0m \u001b[43mdbi_eval\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstep\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstep_best\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43md\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mflip_list\u001b[49m\u001b[43m[\u001b[49m\u001b[43mi\u001b[49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[43md\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 112\u001b[0m optimal_steps[i] \u001b[38;5;241m=\u001b[39m step_best\n\u001b[1;32m 113\u001b[0m norms_off_diagonal_restriction[i] \u001b[38;5;241m=\u001b[39m dbi_eval\u001b[38;5;241m.\u001b[39moff_diagonal_norm\n", + "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/qibo/models/dbi/double_bracket.py:87\u001b[0m, in \u001b[0;36mDoubleBracketIteration.__call__\u001b[0;34m(self, step, mode, d)\u001b[0m\n\u001b[1;32m 84\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m d \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 85\u001b[0m d \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdiagonal_h_matrix\n\u001b[1;32m 86\u001b[0m operator \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mbackend\u001b[38;5;241m.\u001b[39mcalculate_matrix_exp(\n\u001b[0;32m---> 87\u001b[0m \u001b[38;5;241;43m1.0\u001b[39;49m\u001b[43mj\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mstep\u001b[49m,\n\u001b[1;32m 88\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcommutator(d, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mh\u001b[38;5;241m.\u001b[39mmatrix),\n\u001b[1;32m 89\u001b[0m )\n\u001b[1;32m 90\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m mode \u001b[38;5;129;01mis\u001b[39;00m DoubleBracketGeneratorType\u001b[38;5;241m.\u001b[39mgroup_commutator:\n\u001b[1;32m 91\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m d \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", + "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for *: 'complex' and 'NoneType'" + ] + } + ], "source": [ "NSTEPS = 8\n", "scheduling_list = [DoubleBracketScheduling.grid_search,\n", @@ -374,9 +566,25 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "OMP: Info #276: omp_set_nested routine deprecated, please use omp_set_max_active_levels instead.\n", + "[Qibo 0.2.5|INFO|2024-03-05 15:10:49]: Using qibojit (numba) backend on /CPU:0\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initial off diagonal norm 37.94733192202055\n" + ] + } + ], "source": [ "# Hamiltonian\n", "set_backend(\"qibojit\", \"numba\")\n", @@ -403,25 +611,48 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "None\n" + ] + } + ], "source": [ - "step, coef = dbi.polynomial_step(n=1)\n", - "print(step, coef)" + "step = dbi.choose_step(n=1)\n", + "print(step)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.026973122528658938 None None\n" + ] + } + ], "source": [ - "step_backup_poly = dbi.choose_step(backup_scheduling=DoubleBracketScheduling.polynomial_approximation, n=1, n_max=5)\n", + "step_backup_poly = dbi.choose_step(backup_scheduling=DoubleBracketScheduling.polynomial_approximation, n=4, n_max=5)\n", "step_backup_grid = dbi.choose_step(backup_scheduling=DoubleBracketScheduling.grid_search, n=1)\n", "step_backup_hyper = dbi.choose_step(backup_scheduling=DoubleBracketScheduling.hyperopt, n=1)\n", "print(step_backup_poly, step_backup_grid, step_backup_hyper)" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index ffd371110c..9433befa0d 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -1,15 +1,16 @@ -import math from copy import deepcopy from enum import Enum, auto -from functools import partial from typing import Optional import hyperopt import numpy as np from qibo.hamiltonians import Hamiltonian - -error = 1e-3 +from qibo.models.dbi.utils_scheduling import ( + grid_search_step, + hyperopt_step, + polynomial_step, +) class DoubleBracketGeneratorType(Enum): @@ -27,11 +28,11 @@ class DoubleBracketGeneratorType(Enum): class DoubleBracketScheduling(Enum): """Define the DBI scheduling strategies.""" - hyperopt = auto() + hyperopt = hyperopt_step """Use hyperopt package.""" - grid_search = auto() + grid_search = grid_search_step """Use greedy grid search.""" - polynomial_approximation = auto() + polynomial_approximation = polynomial_step """Use polynomial expansion (analytical) of the loss function.""" @@ -131,135 +132,6 @@ def backend(self): """Get Hamiltonian's backend.""" return self.h0.backend - def grid_search_step( - self, - step_min: float = 1e-5, - step_max: float = 1, - num_evals: int = 100, - space: Optional[np.array] = None, - d: Optional[np.array] = None, - ): - """ - Greedy optimization of the iteration step. - - Args: - step_min: lower bound of the search grid; - step_max: upper bound of the search grid; - mnum_evals: number of iterations between step_min and step_max; - d: diagonal operator for generating double-bracket iterations. - - Returns: - (float): optimized best iteration step (minimizing off-diagonal norm). - """ - if space is None: - space = np.linspace(step_min, step_max, num_evals) - - if d is None: - d = self.diagonal_h_matrix - - loss_list = [self.loss(step, d=d) for step in space] - idx_max_loss = np.argmin(loss_list) - return space[idx_max_loss] - - def hyperopt_step( - self, - step_min: float = 1e-5, - step_max: float = 1, - max_evals: int = 500, - space: callable = None, - optimizer: callable = None, - look_ahead: int = 1, - verbose: bool = False, - d: Optional[np.array] = None, - ): - """ - Optimize iteration step using hyperopt. - - Args: - step_min: lower bound of the search grid; - step_max: upper bound of the search grid; - max_evals: maximum number of iterations done by the hyperoptimizer; - space: see hyperopt.hp possibilities; - optimizer: see hyperopt algorithms; - look_ahead: number of iteration steps to compute the loss function; - verbose: level of verbosity; - d: diagonal operator for generating double-bracket iterations. - - Returns: - (float): optimized best iteration step (minimizing off-diagonal norm). - """ - if space is None: - space = hyperopt.hp.uniform - if optimizer is None: - optimizer = hyperopt.tpe - if d is None: - d = self.diagonal_h_matrix - - space = space("step", step_min, step_max) - best = hyperopt.fmin( - fn=partial(self.loss, d=d, look_ahead=look_ahead), - space=space, - algo=optimizer.suggest, - max_evals=max_evals, - verbose=verbose, - ) - return best["step"] - - def polynomial_step( - self, - n: int = 2, - n_max: int = 5, - d: np.array = None, - backup_scheduling: DoubleBracketScheduling = None, - ): - r""" - Optimizes iteration step by solving the n_th order polynomial expansion of the loss function. - e.g. $n=2$: $2\Trace(\sigma(\Gamma_1 + s\Gamma_2 + s^2/2\Gamma_3)\sigma(\Gamma_0 + s\Gamma_1 + s^2/2\Gamma_2)) - Args: - n (int, optional): the order to which the loss function is expanded. Defaults to 4. - n_max (int, optional): maximum order allowed for recurring calls of `polynomial_step`. Defaults to 5. - d (np.array, optional): diagonal operator, default as $\delta(H)$. - backup_scheduling (`DoubleBracketScheduling`): the scheduling method to use in case no real positive roots are found. - """ - - if d is None: - d = self.diagonal_h_matrix - - if n > n_max: - raise ValueError( - "No solution can be found with polynomial approximation. Increase `n_max` or use other scheduling methods." - ) - - # generate Gamma's where $\Gamma_{k+1}=[W, \Gamma_{k}], $\Gamma_0=H - W = self.commutator(d, self.sigma(self.h.matrix)) - Gamma_list = self.generate_Gamma_list(n + 2, d) - sigma_Gamma_list = list(map(self.sigma, Gamma_list)) - exp_list = np.array([1 / math.factorial(k) for k in range(n + 1)]) - # coefficients for rotation with [W,H] and H - c1 = exp_list.reshape(-1, 1, 1) * sigma_Gamma_list[1:] - c2 = exp_list.reshape(-1, 1, 1) * sigma_Gamma_list[:-1] - # product coefficient - trace_coefficients = [0] * (2 * n + 1) - for k in range(n + 1): - for j in range(n + 1): - power = k + j - product_matrix = c1[k] @ c2[j] - trace_coefficients[power] += 2 * np.trace(product_matrix) - # coefficients from high to low (n:0) - coef = list(reversed(trace_coefficients[: n + 1])) - roots = np.roots(coef) - real_positive_roots = [ - np.real(root) - for root in roots - if np.imag(root) < error and np.real(root) > 0 - ] - # solution exists, return minimum s - if len(real_positive_roots) > 0: - return min(real_positive_roots), coef - # solution does not exist, return None - else: - return None, coef - def choose_step( self, d: Optional[np.array] = None, @@ -271,28 +143,25 @@ def choose_step( ): if scheduling is None: scheduling = self.scheduling - if scheduling is DoubleBracketScheduling.grid_search: - return self.grid_search_step(d=d, **kwargs) - if scheduling is DoubleBracketScheduling.hyperopt: - return self.hyperopt_step(d=d, **kwargs) - if scheduling is DoubleBracketScheduling.polynomial_approximation: - step, coef = self.polynomial_step(d=d, **kwargs) - # if no solution - if step is None: - if ( - backup_scheduling - == DoubleBracketScheduling.polynomial_approximation - and coef is not None - ): - # if `n` is not provided, try default value - kwargs["n"] = kwargs.get("n", 2) - kwargs["n"] += 1 - step, coef = self.polynomial_step(d=d, **kwargs) - # if n==n_max, return None - else: - # Issue: cannot pass kwargs - step = self.choose_step(d=d, scheduling=backup_scheduling) - return step + return scheduling(self, d=d, **kwargs) + # if scheduling is DoubleBracketScheduling.polynomial_approximation: + # step, coef = self.polynomial_step(d=d, **kwargs) + # # if no solution + # if step is None: + # if ( + # backup_scheduling + # == DoubleBracketScheduling.polynomial_approximation + # and coef is not None + # ): + # # if `n` is not provided, try default value + # kwargs["n"] = kwargs.get("n", 2) + # kwargs["n"] += 1 + # step, coef = self.polynomial_step(d=d, **kwargs) + # # if n==n_max, return None + # else: + # # Issue: cannot pass kwargs + # step = self.choose_step(d=d, scheduling=backup_scheduling) + # return step def loss(self, step: float, d: np.array = None, look_ahead: int = 1): """ diff --git a/src/qibo/models/dbi/utils.py b/src/qibo/models/dbi/utils.py index 52f8a33294..b8f4a2ccca 100644 --- a/src/qibo/models/dbi/utils.py +++ b/src/qibo/models/dbi/utils.py @@ -1,9 +1,10 @@ +import math from copy import deepcopy from itertools import product from typing import Optional +import hyperopt import numpy as np -from hyperopt import hp, tpe from qibo import symbols from qibo.config import raise_error @@ -150,3 +151,26 @@ def cs_angle_sgn(dbi_object, d): ) ) return np.sign(norm) + + +def off_diagonal_norm_polynomial_expansion_coef(dbi_object, d, n): + if d is None: + d = dbi_object.diagonal_h_matrix + # generate Gamma's where $\Gamma_{k+1}=[W, \Gamma_{k}], $\Gamma_0=H + W = dbi_object.commutator(d, dbi_object.sigma(dbi_object.h.matrix)) + Gamma_list = dbi_object.generate_Gamma_list(n + 2, d) + sigma_Gamma_list = list(map(dbi_object.sigma, Gamma_list)) + exp_list = np.array([1 / math.factorial(k) for k in range(n + 1)]) + # coefficients for rotation with [W,H] and H + c1 = exp_list.reshape((-1, 1, 1)) * sigma_Gamma_list[1:] + c2 = exp_list.reshape((-1, 1, 1)) * sigma_Gamma_list[:-1] + # product coefficient + trace_coefficients = [0] * (2 * n + 1) + for k in range(n + 1): + for j in range(n + 1): + power = k + j + product_matrix = c1[k] @ c2[j] + trace_coefficients[power] += 2 * np.trace(product_matrix) + # coefficients from high to low (n:0) + coef = list(reversed(trace_coefficients[: n + 1])) + return coef diff --git a/src/qibo/models/dbi/utils_scheduling.py b/src/qibo/models/dbi/utils_scheduling.py new file mode 100644 index 0000000000..d847f33ea5 --- /dev/null +++ b/src/qibo/models/dbi/utils_scheduling.py @@ -0,0 +1,145 @@ +import math +from functools import partial +from typing import Optional + +import hyperopt +import numpy as np + +error = 1e-3 + + +def grid_search_step( + dbi_object, + step_min: float = 1e-5, + step_max: float = 1, + num_evals: int = 100, + space: Optional[np.array] = None, + d: Optional[np.array] = None, +): + """ + Greedy optimization of the iteration step. + + Args: + step_min: lower bound of the search grid; + step_max: upper bound of the search grid; + mnum_evals: number of iterations between step_min and step_max; + d: diagonal operator for generating double-bracket iterations. + + Returns: + (float): optimized best iteration step (minimizing off-diagonal norm). + """ + if space is None: + space = np.linspace(step_min, step_max, num_evals) + + if d is None: + d = dbi_object.diagonal_h_matrix + + loss_list = [dbi_object.loss(step, d=d) for step in space] + idx_max_loss = np.argmin(loss_list) + return space[idx_max_loss] + + +def hyperopt_step( + dbi_object, + step_min: float = 1e-5, + step_max: float = 1, + max_evals: int = 500, + space: callable = None, + optimizer: callable = None, + look_ahead: int = 1, + verbose: bool = False, + d: Optional[np.array] = None, +): + """ + Optimize iteration step using hyperopt. + + Args: + step_min: lower bound of the search grid; + step_max: upper bound of the search grid; + max_evals: maximum number of iterations done by the hyperoptimizer; + space: see hyperopt.hp possibilities; + optimizer: see hyperopt algorithms; + look_ahead: number of iteration steps to compute the loss function; + verbose: level of verbosity; + d: diagonal operator for generating double-bracket iterations. + + Returns: + (float): optimized best iteration step (minimizing off-diagonal norm). + """ + if space is None: + space = hyperopt.hp.uniform + if optimizer is None: + optimizer = hyperopt.tpe + if d is None: + d = dbi_object.diagonal_h_matrix + + space = space("step", step_min, step_max) + best = hyperopt.fmin( + fn=partial(dbi_object.loss, d=d, look_ahead=look_ahead), + space=space, + algo=optimizer.suggest, + max_evals=max_evals, + verbose=verbose, + ) + return best["step"] + + +def polynomial_step( + dbi_object, + n: int = 2, + n_max: int = 5, + d: np.array = None, + coef: Optional[list] = None, +): + r""" + Optimizes iteration step by solving the n_th order polynomial expansion of the loss function. + e.g. $n=2$: $2\Trace(\sigma(\Gamma_1 + s\Gamma_2 + s^2/2\Gamma_3)\sigma(\Gamma_0 + s\Gamma_1 + s^2/2\Gamma_2)) + Args: + n (int, optional): the order to which the loss function is expanded. Defaults to 4. + n_max (int, optional): maximum order allowed for recurring calls of `polynomial_step`. Defaults to 5. + d (np.array, optional): diagonal operator, default as $\delta(H)$. + backup_scheduling (`DoubleBracketScheduling`): the scheduling method to use in case no real positive roots are found. + """ + + if d is None: + d = dbi_object.diagonal_h_matrix + + if n > n_max: + raise ValueError( + "No solution can be found with polynomial approximation. Increase `n_max` or use other scheduling methods." + ) + if coef is None: + coef = off_diagonal_norm_polynomial_expansion_coef(dbi_object, d, n) + roots = np.roots(coef) + real_positive_roots = [ + np.real(root) for root in roots if np.imag(root) < error and np.real(root) > 0 + ] + # solution exists, return minimum s + if len(real_positive_roots) > 0: + return min(real_positive_roots) + # solution does not exist, return None + else: + return None + + +def off_diagonal_norm_polynomial_expansion_coef(dbi_object, d, n): + if d is None: + d = dbi_object.diagonal_h_matrix + # generate Gamma's where $\Gamma_{k+1}=[W, \Gamma_{k}], $\Gamma_0=H + W = dbi_object.commutator(d, dbi_object.sigma(dbi_object.h.matrix)) + Gamma_list = dbi_object.generate_Gamma_list(n + 2, d) + sigma_Gamma_list = list(map(dbi_object.sigma, Gamma_list)) + exp_list = np.array([1 / math.factorial(k) for k in range(n + 1)]) + # coefficients for rotation with [W,H] and H + c1 = exp_list.reshape((-1, 1, 1)) * sigma_Gamma_list[1:] + c2 = exp_list.reshape((-1, 1, 1)) * sigma_Gamma_list[:-1] + # product coefficient + trace_coefficients = [0] * (2 * n + 1) + for k in range(n + 1): + for j in range(n + 1): + power = k + j + product_matrix = c1[k] @ c2[j] + trace_coefficients[power] += 2 * np.trace(product_matrix) + # coefficients from high to low (n:0) + coef = list(reversed(trace_coefficients[: n + 1])) + return coef From 027dc0006ed12b2370f254f31ec1d67223622792 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Tue, 5 Mar 2024 16:00:38 +0800 Subject: [PATCH 17/22] Simplify backup option in `choose_step` --- examples/dbi/dbi_scheduling.ipynb | 308 +++----------------------- src/qibo/models/dbi/double_bracket.py | 32 +-- 2 files changed, 44 insertions(+), 296 deletions(-) diff --git a/examples/dbi/dbi_scheduling.ipynb b/examples/dbi/dbi_scheduling.ipynb index 34a49760b5..f871394c4f 100644 --- a/examples/dbi/dbi_scheduling.ipynb +++ b/examples/dbi/dbi_scheduling.ipynb @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -43,25 +43,9 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "OMP: Info #276: omp_set_nested routine deprecated, please use omp_set_max_active_levels instead.\n", - "[Qibo 0.2.5|INFO|2024-03-05 15:06:24]: Using qibojit (numba) backend on /CPU:0\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Initial off diagonal norm 37.94733192202055\n" - ] - } - ], + "outputs": [], "source": [ "# Hamiltonian\n", "set_backend(\"qibojit\", \"numba\")\n", @@ -87,7 +71,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -110,19 +94,9 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "grid_search step: 0.030312727272727272\n", - "hyperopt_search step: 0.028991467713834373\n", - "polynomial_approximation step: 0.032960905003724034\n" - ] - } - ], + "outputs": [], "source": [ "# grid_search\n", "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.grid_search)\n", @@ -136,34 +110,9 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The minimum for cost function in the tested range is:" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " 0.030312727272727272\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Plot the results\n", "plt.plot(s_space, off_diagonal_norm_diff)\n", @@ -188,18 +137,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.5|WARNING|2024-03-05 15:06:24]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-05 15:06:24]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" - ] - } - ], + "outputs": [], "source": [ "# Generate the digaonal operators\n", "Z_str = \"Z\"*nqubits\n", @@ -211,7 +151,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -229,19 +169,9 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "grid_search step: 0.30303525252525254 loss -6.165348149025746\n", - "hyperopt_search step: 0.30457003862873383 loss -6.158069649792722\n", - "polynomial_approximation step: 0.040336885340305856 loss -6.149780650249902\n" - ] - } - ], + "outputs": [], "source": [ "# grid_search\n", "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.grid_search, step_max=0.6, d=d)\n", @@ -259,27 +189,9 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The minimum for cost function in the tested range is: 0.30303525252525254\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Plot the results\n", "plt.plot(s_space, off_diagonal_norm_diff)\n", @@ -311,18 +223,9 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "grid_search step: 0.04141414141414142\n", - "hyperopt_search step: 0.041686777442654525\n" - ] - } - ], + "outputs": [], "source": [ "search_range = 0.1\n", "if step_poly < search_range/2:\n", @@ -341,27 +244,9 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The minimum for cost function in the tested range is: 0.04141414141414142\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Plot the results\n", "plt.plot(s_space, off_diagonal_norm_diff)\n", @@ -391,7 +276,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -401,24 +286,9 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.5|INFO|2024-03-05 15:06:25]: Using qibojit (numba) backend on /CPU:0\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Initial off diagonal norm 15.582565474255802\n" - ] - } - ], + "outputs": [], "source": [ "# Hamiltonian\n", "set_backend(\"qibojit\", \"numba\")\n", @@ -432,31 +302,9 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-03-05 15:06:25]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" - ] - } - ], + "outputs": [], "source": [ "generate_local_Z = generate_Z_operators(nqubits)\n", "Z_ops = list(generate_local_Z.values())\n", @@ -465,48 +313,9 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "----------Scheduling grid search----------\n", - "New optimized step at iteration 1/8: 0.09091818181818181 with operator -IIIZ, loss 12.06390502880173\n", - "New optimized step at iteration 2/8: 0.08081727272727272 with operator -IIIZ, loss 9.635355222386766\n", - "New optimized step at iteration 3/8: 0.09091818181818181 with operator ZZII, loss 8.551120821934958\n", - "New optimized step at iteration 4/8: 0.06061545454545455 with operator -IIIZ, loss 7.454888988134408\n", - "New optimized step at iteration 5/8: 0.09091818181818181 with operator ZZII, loss 6.526038310796992\n", - "New optimized step at iteration 6/8: 0.07071636363636363 with operator -IIIZ, loss 5.906198775254362\n", - "New optimized step at iteration 7/8: 0.07071636363636363 with operator -IIIZ, loss 5.558604782647778\n", - "New optimized step at iteration 8/8: 0.09091818181818181 with operator IIZI, loss 5.248002043412237\n", - "----------Scheduling hyperopt----------\n", - "New optimized step at iteration 1/8: 0.0952680083828445 with operator -IIIZ, loss 12.048611508414254\n", - "New optimized step at iteration 2/8: 0.0759399266935567 with operator -IIIZ, loss 9.647010146511933\n", - "New optimized step at iteration 3/8: 0.0953305046594857 with operator ZZII, loss 8.545812587336131\n", - "New optimized step at iteration 4/8: 0.0638318397684811 with operator -IIIZ, loss 7.391689830573071\n", - "New optimized step at iteration 5/8: 0.0857170843370093 with operator ZZII, loss 6.534188669695426\n", - "New optimized step at iteration 6/8: 0.06796907471647104 with operator -IIIZ, loss 5.930126378868041\n", - "New optimized step at iteration 7/8: 0.06714742808838461 with operator -IIIZ, loss 5.582951426889378\n", - "New optimized step at iteration 8/8: 0.10283381512622272 with operator IIZI, loss 5.253925034956114\n", - "----------Scheduling polynomial----------\n" - ] - }, - { - "ename": "TypeError", - "evalue": "unsupported operand type(s) for *: 'complex' and 'NoneType'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[15], line 20\u001b[0m\n\u001b[1;32m 18\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m----------Scheduling \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mscheduling_labels[i]\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m----------\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m 19\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m _ \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(NSTEPS):\n\u001b[0;32m---> 20\u001b[0m dbi, idx, step, flip_sign \u001b[38;5;241m=\u001b[39m \u001b[43mselect_best_dbr_generator\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdbi\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mZ_ops\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mscheduling\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mscheduling\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcompare_canonical\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[1;32m 21\u001b[0m off_diagonal_norm_history\u001b[38;5;241m.\u001b[39mappend(dbi\u001b[38;5;241m.\u001b[39moff_diagonal_norm)\n\u001b[1;32m 22\u001b[0m steps\u001b[38;5;241m.\u001b[39mappend(steps[\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]\u001b[38;5;241m+\u001b[39mstep)\n", - "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/qibo/models/dbi/utils.py:111\u001b[0m, in \u001b[0;36mselect_best_dbr_generator\u001b[0;34m(dbi_object, d_list, step, compare_canonical, scheduling, **kwargs)\u001b[0m\n\u001b[1;32m 109\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 110\u001b[0m step_best \u001b[38;5;241m=\u001b[39m step\n\u001b[0;32m--> 111\u001b[0m \u001b[43mdbi_eval\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstep\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstep_best\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43md\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mflip_list\u001b[49m\u001b[43m[\u001b[49m\u001b[43mi\u001b[49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[43md\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 112\u001b[0m optimal_steps[i] \u001b[38;5;241m=\u001b[39m step_best\n\u001b[1;32m 113\u001b[0m norms_off_diagonal_restriction[i] \u001b[38;5;241m=\u001b[39m dbi_eval\u001b[38;5;241m.\u001b[39moff_diagonal_norm\n", - "File \u001b[0;32m~/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/qibo/models/dbi/double_bracket.py:87\u001b[0m, in \u001b[0;36mDoubleBracketIteration.__call__\u001b[0;34m(self, step, mode, d)\u001b[0m\n\u001b[1;32m 84\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m d \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 85\u001b[0m d \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdiagonal_h_matrix\n\u001b[1;32m 86\u001b[0m operator \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mbackend\u001b[38;5;241m.\u001b[39mcalculate_matrix_exp(\n\u001b[0;32m---> 87\u001b[0m \u001b[38;5;241;43m1.0\u001b[39;49m\u001b[43mj\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mstep\u001b[49m,\n\u001b[1;32m 88\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcommutator(d, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mh\u001b[38;5;241m.\u001b[39mmatrix),\n\u001b[1;32m 89\u001b[0m )\n\u001b[1;32m 90\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m mode \u001b[38;5;129;01mis\u001b[39;00m DoubleBracketGeneratorType\u001b[38;5;241m.\u001b[39mgroup_commutator:\n\u001b[1;32m 91\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m d \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", - "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for *: 'complex' and 'NoneType'" - ] - } - ], + "outputs": [], "source": [ "NSTEPS = 8\n", "scheduling_list = [DoubleBracketScheduling.grid_search,\n", @@ -566,25 +375,9 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "OMP: Info #276: omp_set_nested routine deprecated, please use omp_set_max_active_levels instead.\n", - "[Qibo 0.2.5|INFO|2024-03-05 15:10:49]: Using qibojit (numba) backend on /CPU:0\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Initial off diagonal norm 37.94733192202055\n" - ] - } - ], + "outputs": [], "source": [ "# Hamiltonian\n", "set_backend(\"qibojit\", \"numba\")\n", @@ -609,50 +402,17 @@ "For demonstration purposes, we let `n=1` which is a linear fit to the loss function. This results in no valid solutions and function `polynomial_step` returns `None`." ] }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "None\n" - ] - } - ], - "source": [ - "step = dbi.choose_step(n=1)\n", - "print(step)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.026973122528658938 None None\n" - ] - } - ], - "source": [ - "step_backup_poly = dbi.choose_step(backup_scheduling=DoubleBracketScheduling.polynomial_approximation, n=4, n_max=5)\n", - "step_backup_grid = dbi.choose_step(backup_scheduling=DoubleBracketScheduling.grid_search, n=1)\n", - "step_backup_hyper = dbi.choose_step(backup_scheduling=DoubleBracketScheduling.hyperopt, n=1)\n", - "print(step_backup_poly, step_backup_grid, step_backup_hyper)" - ] - }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "for n in range (5):\n", + " step = polynomial_step(dbi, n=n)\n", + " print(n, step)\n", + "print(dbi.choose_step(n=1))" + ] } ], "metadata": { diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index 9433befa0d..fe5ef050f8 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -136,32 +136,20 @@ def choose_step( self, d: Optional[np.array] = None, scheduling: Optional[DoubleBracketScheduling] = None, - backup_scheduling: Optional[ - DoubleBracketScheduling - ] = DoubleBracketScheduling.hyperopt, **kwargs, ): if scheduling is None: scheduling = self.scheduling - return scheduling(self, d=d, **kwargs) - # if scheduling is DoubleBracketScheduling.polynomial_approximation: - # step, coef = self.polynomial_step(d=d, **kwargs) - # # if no solution - # if step is None: - # if ( - # backup_scheduling - # == DoubleBracketScheduling.polynomial_approximation - # and coef is not None - # ): - # # if `n` is not provided, try default value - # kwargs["n"] = kwargs.get("n", 2) - # kwargs["n"] += 1 - # step, coef = self.polynomial_step(d=d, **kwargs) - # # if n==n_max, return None - # else: - # # Issue: cannot pass kwargs - # step = self.choose_step(d=d, scheduling=backup_scheduling) - # return step + step = scheduling(self, d=d, **kwargs) + if ( + step is None + and scheduling == DoubleBracketScheduling.polynomial_approximation + ): + kwargs["n"] = kwargs.get("n", 3) + kwargs["n"] += 1 + # if n==n_max, return None + step = scheduling(self, d=d, **kwargs) + return step def loss(self, step: float, d: np.array = None, look_ahead: int = 1): """ From 743f947ab79e7e5822fbc928456b6fe7231ca233 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Wed, 6 Mar 2024 09:08:29 +0800 Subject: [PATCH 18/22] Fix test for new structure --- examples/dbi/dbi_scheduling.ipynb | 4 ++-- tests/test_models_dbi.py | 23 +++++++---------------- 2 files changed, 9 insertions(+), 18 deletions(-) diff --git a/examples/dbi/dbi_scheduling.ipynb b/examples/dbi/dbi_scheduling.ipynb index f871394c4f..3440716a85 100644 --- a/examples/dbi/dbi_scheduling.ipynb +++ b/examples/dbi/dbi_scheduling.ipynb @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -276,7 +276,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ diff --git a/tests/test_models_dbi.py b/tests/test_models_dbi.py index 111079f8a7..1dcbb960d0 100644 --- a/tests/test_models_dbi.py +++ b/tests/test_models_dbi.py @@ -72,25 +72,25 @@ def test_hyperopt_step(backend, nqubits): h0 = random_hermitian(2**nqubits, backend=backend, seed=seed) d = backend.cast(np.diag(np.diag(backend.to_numpy(h0)))) dbi = DoubleBracketIteration(Hamiltonian(nqubits, h0, backend=backend)) - + dbi.scheduling = DoubleBracketScheduling.hyperopt # find initial best step with look_ahead = 1 initial_step = 0.01 delta = 0.02 - step = dbi.hyperopt_step( + step = dbi.choose_step( step_min=initial_step - delta, step_max=initial_step + delta, max_evals=100 ) assert step != initial_step - # evolve following the optimized first step + # evolve following with optimized first step for generator in DoubleBracketGeneratorType: dbi(mode=generator, step=step, d=d) # find the following step size with look_ahead look_ahead = 3 - step = dbi.hyperopt_step( + step = dbi.choose_step( step_min=initial_step - delta, step_max=initial_step + delta, max_evals=100, @@ -134,13 +134,8 @@ def test_double_bracket_iteration_scheduling_grid_hyperopt( @pytest.mark.parametrize("nqubits", [3, 4, 6]) -@pytest.mark.parametrize("n", [2, 3]) -@pytest.mark.parametrize( - "backup_scheduling", [None, DoubleBracketScheduling.polynomial_approximation] -) -def test_double_bracket_iteration_scheduling_polynomial( - backend, nqubits, n, backup_scheduling -): +@pytest.mark.parametrize("n", [2, 4]) +def test_double_bracket_iteration_scheduling_polynomial(backend, nqubits, n): h0 = random_hermitian(2**nqubits, backend=backend, seed=seed) d = backend.cast(np.diag(np.diag(backend.to_numpy(h0)))) dbi = DoubleBracketIteration( @@ -150,10 +145,6 @@ def test_double_bracket_iteration_scheduling_polynomial( ) initial_off_diagonal_norm = dbi.off_diagonal_norm for _ in range(NSTEPS): - step1 = dbi.choose_step(n=n, backup_scheduling=backup_scheduling) + step1 = dbi.choose_step(d=d, n=n) dbi(d=d, step=step1) - # step2 = dbi.choose_step( - # scheduling=DoubleBracketScheduling.polynomial_approximation, n=n - # ) - # dbi(step=step2) assert initial_off_diagonal_norm > dbi.off_diagonal_norm From 00f6d8c89b03fccb3494779dbb25b0f1aa360a82 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Wed, 6 Mar 2024 09:34:04 +0800 Subject: [PATCH 19/22] Test coverage for fail cases in polynomial step --- tests/test_models_dbi.py | 6 ++--- tests/test_models_dbi_utils.py | 1 + tests/test_models_dbi_utils_scheduling.py | 30 +++++++++++++++++++++++ 3 files changed, 34 insertions(+), 3 deletions(-) create mode 100644 tests/test_models_dbi_utils_scheduling.py diff --git a/tests/test_models_dbi.py b/tests/test_models_dbi.py index 1dcbb960d0..5fa277f7ac 100644 --- a/tests/test_models_dbi.py +++ b/tests/test_models_dbi.py @@ -137,7 +137,6 @@ def test_double_bracket_iteration_scheduling_grid_hyperopt( @pytest.mark.parametrize("n", [2, 4]) def test_double_bracket_iteration_scheduling_polynomial(backend, nqubits, n): h0 = random_hermitian(2**nqubits, backend=backend, seed=seed) - d = backend.cast(np.diag(np.diag(backend.to_numpy(h0)))) dbi = DoubleBracketIteration( Hamiltonian(nqubits, h0, backend=backend), mode=DoubleBracketGeneratorType.single_commutator, @@ -145,6 +144,7 @@ def test_double_bracket_iteration_scheduling_polynomial(backend, nqubits, n): ) initial_off_diagonal_norm = dbi.off_diagonal_norm for _ in range(NSTEPS): - step1 = dbi.choose_step(d=d, n=n) - dbi(d=d, step=step1) + # by default, d is the diagonal resctriction of H + step1 = dbi.choose_step(n=n) + dbi(step=step1) assert initial_off_diagonal_norm > dbi.off_diagonal_norm diff --git a/tests/test_models_dbi_utils.py b/tests/test_models_dbi_utils.py index cd9f74e9de..a19ee502c5 100644 --- a/tests/test_models_dbi_utils.py +++ b/tests/test_models_dbi_utils.py @@ -37,6 +37,7 @@ def test_select_best_dbr_generator(backend, nqubits, step): dbi = DoubleBracketIteration( Hamiltonian(nqubits, h0, backend=backend), mode=DoubleBracketGeneratorType.single_commutator, + scheduling=DoubleBracketScheduling.grid_search, ) generate_Z = generate_Z_operators(nqubits) Z_ops = list(generate_Z.values()) diff --git a/tests/test_models_dbi_utils_scheduling.py b/tests/test_models_dbi_utils_scheduling.py new file mode 100644 index 0000000000..392727f144 --- /dev/null +++ b/tests/test_models_dbi_utils_scheduling.py @@ -0,0 +1,30 @@ +"""Unit testing for utils_scheduling.py for Double Bracket Iteration""" + +import numpy as np +import pytest + +from qibo.hamiltonians import Hamiltonian +from qibo.models.dbi.double_bracket import ( + DoubleBracketGeneratorType, + DoubleBracketIteration, + DoubleBracketScheduling, +) +from qibo.models.dbi.utils_scheduling import polynomial_step +from qibo.quantum_info import random_hermitian + +NSTEPS = 1 +seed = 10 +"""Number of steps for evolution.""" + + +@pytest.mark.parametrize("nqubits", [5, 6]) +def test_polynomial_fail_cases(backend, nqubits): + h0 = random_hermitian(2**nqubits, backend=backend, seed=seed) + dbi = DoubleBracketIteration( + Hamiltonian(nqubits, h0, backend=backend), + mode=DoubleBracketGeneratorType.single_commutator, + scheduling=DoubleBracketScheduling.polynomial_approximation, + ) + with pytest.raises(ValueError): + polynomial_step(dbi, n=2, n_max=1) + assert polynomial_step(dbi, n=1) == None From 08f8977e924151f9d5957da2c683f6f9a0dbf426 Mon Sep 17 00:00:00 2001 From: wrightjandrew <115216427+wrightjandrew@users.noreply.github.com> Date: Tue, 12 Mar 2024 17:25:43 +0100 Subject: [PATCH 20/22] added new cost functions --- src/qibo/models/dbi/double_bracket.py | 30 +++++++++++++- src/qibo/models/dbi/utils.py | 1 + src/qibo/models/dbi/utils_scheduling.py | 52 +++++++++++++++++++++++-- 3 files changed, 78 insertions(+), 5 deletions(-) diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index fe5ef050f8..e5db4629ee 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -35,6 +35,15 @@ class DoubleBracketScheduling(Enum): polynomial_approximation = polynomial_step """Use polynomial expansion (analytical) of the loss function.""" +class DoubleBracketCostFunction(Enum): + """Define the DBI cost function.""" + + off_diagonal_norm = auto() + """Use off-diagonal norm as cost function.""" + least_squares = auto() + """Use least squares as cost function.""" + energy_fluctuation = auto() + """Use energy fluctuation as cost function.""" class DoubleBracketIteration: """ @@ -65,11 +74,15 @@ def __init__( hamiltonian: Hamiltonian, mode: DoubleBracketGeneratorType = DoubleBracketGeneratorType.canonical, scheduling: DoubleBracketScheduling = DoubleBracketScheduling.grid_search, + cost: DoubleBracketCostFunction = DoubleBracketCostFunction.off_diagonal_norm, + state: int = 0, ): self.h = hamiltonian self.h0 = deepcopy(self.h) self.mode = mode self.scheduling = scheduling + self.cost = cost + self.state = state def __call__( self, step: float, mode: DoubleBracketGeneratorType = None, d: np.array = None @@ -126,6 +139,14 @@ def off_diagonal_norm(self): return np.sqrt( np.real(np.trace(self.backend.to_numpy(off_diag_h_dag @ self.off_diag_h))) ) + @property + def least_squares(self,d: np.array): + """Least squares cost function.""" + H = self.backend.cast( + np.matrix(self.backend.to_numpy(self.h)).getH() + ) + D = d + return -(np.linalg.trace(H@D)-0.5(np.linalg.norm(H)**2+np.linalg.norm(D)**2)) @property def backend(self): @@ -166,8 +187,13 @@ def loss(self, step: float, d: np.array = None, look_ahead: int = 1): for _ in range(look_ahead): self.__call__(mode=self.mode, step=step, d=d) - # off_diagonal_norm's value after the steps - loss = self.off_diagonal_norm + # loss values depending on the cost function + if self.cost == DoubleBracketCostFunction.off_diagonal_norm: + loss = self.off_diagonal_norm + elif self.cost == DoubleBracketCostFunction.least_squares: + loss = self.least_squares(d=d) + else: + loss = self.energy_fluctuation(self.state) # set back the initial configuration self.h = h_copy diff --git a/src/qibo/models/dbi/utils.py b/src/qibo/models/dbi/utils.py index b8f4a2ccca..b1dd5daf61 100644 --- a/src/qibo/models/dbi/utils.py +++ b/src/qibo/models/dbi/utils.py @@ -174,3 +174,4 @@ def off_diagonal_norm_polynomial_expansion_coef(dbi_object, d, n): # coefficients from high to low (n:0) coef = list(reversed(trace_coefficients[: n + 1])) return coef + diff --git a/src/qibo/models/dbi/utils_scheduling.py b/src/qibo/models/dbi/utils_scheduling.py index d847f33ea5..5ceb3eba64 100644 --- a/src/qibo/models/dbi/utils_scheduling.py +++ b/src/qibo/models/dbi/utils_scheduling.py @@ -7,6 +7,15 @@ error = 1e-3 +def variance(A, state): + """Calculates the variance of a matrix A with respect to a state: Var($A$) = $\langle\mu|A^2|\mu\rangle-\langle\mu|A|\mu\rangle^2$""" + B = A@A + return B[state,state]-A[state,state]**2 + +def covariance(A, B, state): + """Calculates the covariance of two matrices A and B with respect to a state: Cov($A,B$) = $\langle\mu|AB|\mu\rangle-\langle\mu|A|\mu\rangle\langle\mu|B|\mu\rangle$""" + C = A@B + return C[state,state]-A[state,state]*B[state,state] def grid_search_step( dbi_object, @@ -64,7 +73,7 @@ def hyperopt_step( d: diagonal operator for generating double-bracket iterations. Returns: - (float): optimized best iteration step (minimizing off-diagonal norm). + (float): optimized best iteration step (minimizing loss function). """ if space is None: space = hyperopt.hp.uniform @@ -90,6 +99,7 @@ def polynomial_step( n_max: int = 5, d: np.array = None, coef: Optional[list] = None, + cost: str = None, ): r""" Optimizes iteration step by solving the n_th order polynomial expansion of the loss function. @@ -100,7 +110,8 @@ def polynomial_step( d (np.array, optional): diagonal operator, default as $\delta(H)$. backup_scheduling (`DoubleBracketScheduling`): the scheduling method to use in case no real positive roots are found. """ - + if cost is None: + cost = dbi_object.cost if d is None: d = dbi_object.diagonal_h_matrix @@ -109,7 +120,15 @@ def polynomial_step( "No solution can be found with polynomial approximation. Increase `n_max` or use other scheduling methods." ) if coef is None: - coef = off_diagonal_norm_polynomial_expansion_coef(dbi_object, d, n) + if cost == "off_diagonal_norm": + coef = off_diagonal_norm_polynomial_expansion_coef(dbi_object, d, n) + elif cost == "least_squares": + coef = least_squares_polynomial_expansion_coef(dbi_object, d, n) + elif cost == "energy_fluctuation": + coef = energy_fluctuation_polynomial_expansion_coef(dbi_object, d, n, dbi_object.state) + else: + raise ValueError(f"Cost function {cost} not recognized.") + roots = np.roots(coef) real_positive_roots = [ np.real(root) for root in roots if np.imag(root) < error and np.real(root) > 0 @@ -143,3 +162,30 @@ def off_diagonal_norm_polynomial_expansion_coef(dbi_object, d, n): # coefficients from high to low (n:0) coef = list(reversed(trace_coefficients[: n + 1])) return coef + +def least_squares_polynomial_expansion_coef(dbi_object, d, n): + if d is None: + d = dbi_object.diagonal_h_matrix + # generate Gamma's where $\Gamma_{k+1}=[W, \Gamma_{k}], $\Gamma_0=H + W = dbi_object.commutator(d, dbi_object.sigma(dbi_object.h.matrix)) + Gamma_list = dbi_object.generate_Gamma_list(n, d) + exp_list = np.array([1 / math.factorial(k) for k in range(n + 1)]) + # coefficients + coef = np.empty(n) + for i in range(n): + coef[i] = exp_list[i]*np.trace(d@Gamma_list[i+1]) + + return coef + +#TODO: add a general expansion formula not stopping at 3rd order +def energy_fluctuation_polynomial_expansion_coef(dbi_object, d, n, state): + if d is None: + d = dbi_object.diagonal_h_matrix + # generate Gamma's where $\Gamma_{k+1}=[W, \Gamma_{k}], $\Gamma_0=H + Gamma_list = dbi_object.generate_Gamma_list(n, d) + # coefficients + coef = np.empty(3) + coef[0] = 2*covariance(Gamma_list[0], Gamma_list[1],state) + coef[1] = 2*variance(Gamma_list[1],state) + coef[2] = covariance(Gamma_list[0], Gamma_list[3],state)+3*covariance(Gamma_list[1], Gamma_list[2],state) + return coef From f2061f80a549d9f4289674ca8720fce96ef567ff Mon Sep 17 00:00:00 2001 From: wrightjandrew <115216427+wrightjandrew@users.noreply.github.com> Date: Tue, 12 Mar 2024 17:40:23 +0100 Subject: [PATCH 21/22] bug fix: use string of cost function --- examples/dbi/dbi_scheduling.ipynb | 51 +++++++++++++++++++++---- src/qibo/models/dbi/double_bracket.py | 1 + src/qibo/models/dbi/utils_scheduling.py | 2 +- 3 files changed, 45 insertions(+), 9 deletions(-) diff --git a/examples/dbi/dbi_scheduling.ipynb b/examples/dbi/dbi_scheduling.ipynb index 3440716a85..1953c1272d 100644 --- a/examples/dbi/dbi_scheduling.ipynb +++ b/examples/dbi/dbi_scheduling.ipynb @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -43,9 +43,24 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.5|INFO|2024-03-12 17:24:06]: Using qibojit (numba) backend on /CPU:0\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initial off diagonal norm 37.94733192202055\n" + ] + } + ], "source": [ "# Hamiltonian\n", "set_backend(\"qibojit\", \"numba\")\n", @@ -71,7 +86,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -94,9 +109,24 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "TypeError", + "evalue": "loss() got an unexpected keyword argument 'state'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[16], line 2\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[39m# grid_search\u001b[39;00m\n\u001b[1;32m----> 2\u001b[0m step_grid \u001b[39m=\u001b[39m dbi\u001b[39m.\u001b[39;49mchoose_step(scheduling\u001b[39m=\u001b[39;49mDoubleBracketScheduling\u001b[39m.\u001b[39;49mgrid_search)\n\u001b[0;32m 3\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39m'\u001b[39m\u001b[39mgrid_search step:\u001b[39m\u001b[39m'\u001b[39m, step_grid)\n\u001b[0;32m 4\u001b[0m \u001b[39m# hyperopt\u001b[39;00m\n", + "File \u001b[1;32mc:\\Users\\andre\\Documents\\GitHub\\qibo\\.conda\\lib\\site-packages\\qibo\\models\\dbi\\double_bracket.py:164\u001b[0m, in \u001b[0;36mDoubleBracketIteration.choose_step\u001b[1;34m(self, d, scheduling, **kwargs)\u001b[0m\n\u001b[0;32m 162\u001b[0m \u001b[39mif\u001b[39;00m scheduling \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m 163\u001b[0m scheduling \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mscheduling\n\u001b[1;32m--> 164\u001b[0m step \u001b[39m=\u001b[39m scheduling(\u001b[39mself\u001b[39m, d\u001b[39m=\u001b[39md, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n\u001b[0;32m 165\u001b[0m \u001b[39mif\u001b[39;00m (\n\u001b[0;32m 166\u001b[0m step \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m\n\u001b[0;32m 167\u001b[0m \u001b[39mand\u001b[39;00m scheduling \u001b[39m==\u001b[39m DoubleBracketScheduling\u001b[39m.\u001b[39mpolynomial_approximation\n\u001b[0;32m 168\u001b[0m ):\n\u001b[0;32m 169\u001b[0m kwargs[\u001b[39m\"\u001b[39m\u001b[39mn\u001b[39m\u001b[39m\"\u001b[39m] \u001b[39m=\u001b[39m kwargs\u001b[39m.\u001b[39mget(\u001b[39m\"\u001b[39m\u001b[39mn\u001b[39m\u001b[39m\"\u001b[39m, \u001b[39m3\u001b[39m)\n", + "File \u001b[1;32mc:\\Users\\andre\\Documents\\GitHub\\qibo\\.conda\\lib\\site-packages\\qibo\\models\\dbi\\utils_scheduling.py:47\u001b[0m, in \u001b[0;36mgrid_search_step\u001b[1;34m(dbi_object, step_min, step_max, num_evals, space, d, state)\u001b[0m\n\u001b[0;32m 44\u001b[0m \u001b[39mif\u001b[39;00m d \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m 45\u001b[0m d \u001b[39m=\u001b[39m dbi_object\u001b[39m.\u001b[39mdiagonal_h_matrix\n\u001b[1;32m---> 47\u001b[0m loss_list \u001b[39m=\u001b[39m [dbi_object\u001b[39m.\u001b[39mloss(step, d\u001b[39m=\u001b[39md, state\u001b[39m=\u001b[39mstate) \u001b[39mfor\u001b[39;00m step \u001b[39min\u001b[39;00m space]\n\u001b[0;32m 48\u001b[0m idx_max_loss \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39margmin(loss_list)\n\u001b[0;32m 49\u001b[0m \u001b[39mreturn\u001b[39;00m space[idx_max_loss]\n", + "File \u001b[1;32mc:\\Users\\andre\\Documents\\GitHub\\qibo\\.conda\\lib\\site-packages\\qibo\\models\\dbi\\utils_scheduling.py:47\u001b[0m, in \u001b[0;36m\u001b[1;34m(.0)\u001b[0m\n\u001b[0;32m 44\u001b[0m \u001b[39mif\u001b[39;00m d \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m 45\u001b[0m d \u001b[39m=\u001b[39m dbi_object\u001b[39m.\u001b[39mdiagonal_h_matrix\n\u001b[1;32m---> 47\u001b[0m loss_list \u001b[39m=\u001b[39m [dbi_object\u001b[39m.\u001b[39;49mloss(step, d\u001b[39m=\u001b[39;49md, state\u001b[39m=\u001b[39;49mstate) \u001b[39mfor\u001b[39;00m step \u001b[39min\u001b[39;00m space]\n\u001b[0;32m 48\u001b[0m idx_max_loss \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39margmin(loss_list)\n\u001b[0;32m 49\u001b[0m \u001b[39mreturn\u001b[39;00m space[idx_max_loss]\n", + "\u001b[1;31mTypeError\u001b[0m: loss() got an unexpected keyword argument 'state'" + ] + } + ], "source": [ "# grid_search\n", "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.grid_search)\n", @@ -417,7 +447,7 @@ ], "metadata": { "kernelspec": { - "display_name": "DBF_qibo", + "display_name": "Python 3", "language": "python", "name": "python3" }, @@ -431,7 +461,12 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.7" + "version": "3.9.18" + }, + "vscode": { + "interpreter": { + "hash": "48caf7dabad7b721a854729228548373f17e53f40870080394d552284aea7c35" + } } }, "nbformat": 4, diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index e5db4629ee..0446ffbb9a 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -82,6 +82,7 @@ def __init__( self.mode = mode self.scheduling = scheduling self.cost = cost + self.cost_str = cost.name self.state = state def __call__( diff --git a/src/qibo/models/dbi/utils_scheduling.py b/src/qibo/models/dbi/utils_scheduling.py index 5ceb3eba64..2017b57cd1 100644 --- a/src/qibo/models/dbi/utils_scheduling.py +++ b/src/qibo/models/dbi/utils_scheduling.py @@ -111,7 +111,7 @@ def polynomial_step( backup_scheduling (`DoubleBracketScheduling`): the scheduling method to use in case no real positive roots are found. """ if cost is None: - cost = dbi_object.cost + cost = dbi_object.cost.name if d is None: d = dbi_object.diagonal_h_matrix From 93eb20a5743aa57f17f31b3b72dbd6a02de64262 Mon Sep 17 00:00:00 2001 From: wrightjandrew <115216427+wrightjandrew@users.noreply.github.com> Date: Fri, 15 Mar 2024 20:18:35 +0100 Subject: [PATCH 22/22] added full diagonal gradients and a tutorial file --- examples/dbi/dbi_costs.ipynb | 548 ++++++++++++++++++++++++ src/qibo/models/dbi/double_bracket.py | 23 +- src/qibo/models/dbi/utils_scheduling.py | 103 ++++- 3 files changed, 645 insertions(+), 29 deletions(-) create mode 100644 examples/dbi/dbi_costs.ipynb diff --git a/examples/dbi/dbi_costs.ipynb b/examples/dbi/dbi_costs.ipynb new file mode 100644 index 0000000000..558f74cff3 --- /dev/null +++ b/examples/dbi/dbi_costs.ipynb @@ -0,0 +1,548 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Double-bracket Iteration other cost functions and respective scheduling\n", + "\n", + "This notebook presents two additional cost functions for the double-bracket flow: least-squares and energy fluctuation with their respectice scheduling methods." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from copy import deepcopy\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from qibo import hamiltonians, set_backend\n", + "from qibo.models.dbi.double_bracket import DoubleBracketGeneratorType, DoubleBracketScheduling, DoubleBracketIteration, DoubleBracketCostFunction\n", + "from qibo.models.dbi.utils import *\n", + "from qibo.models.dbi.utils_scheduling import *" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Least-squares\n", + "\n", + "The cost function is defined as: $\\frac{1}{2}||D-H_k||^2 =\\frac{1}{2}(||D||^2+||H||^2) -Tr(D H_k)$ as in https://epubs.siam.org/doi/abs/10.1137/S0036141092229732?journalCode=sjmael. We seek to maximize this function at each iteration." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.5|INFO|2024-03-15 18:17:05]: Using qibojit (numba) backend on /CPU:0\n" + ] + } + ], + "source": [ + "# Hamiltonian\n", + "set_backend(\"qibojit\", \"numba\")\n", + "\n", + "# hamiltonian parameters\n", + "nqubits = 5\n", + "h = 3.0\n", + "\n", + "# define the hamiltonian\n", + "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=h)\n", + "\n", + "# define the least-squares cost function\n", + "cost = DoubleBracketCostFunction.least_squares\n", + "# initialize class\n", + "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "grid_search step: 0.02021181818181818\n", + "hyperopt_search step: 0.2796044748864459\n", + "polynomial_approximation step: 0.016462159944159827\n" + ] + } + ], + "source": [ + "# generate data for plotting sigma decrease of the first step\n", + "d = np.diag(np.linspace(1,2**nqubits,2**nqubits))\n", + "s_space = np.linspace(1e-5, 0.6, 1000)\n", + "off_diagonal_norm_diff = []\n", + "potential = []\n", + "for s in s_space:\n", + " dbi_eval = deepcopy(dbi)\n", + " dbi_eval(s,d=d)\n", + " off_diagonal_norm_diff.append(dbi_eval.off_diagonal_norm - dbi.off_diagonal_norm)\n", + " potential.append(dbi_eval.least_squares(D=d))\n", + "\n", + "# grid_search\n", + "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.grid_search,d=d)\n", + "print('grid_search step:', step_grid)\n", + "# hyperopt\n", + "step_hyperopt = dbi.choose_step(scheduling=DoubleBracketScheduling.hyperopt,d=d, max_evals=100, step_max=0.6)\n", + "print('hyperopt_search step:', step_hyperopt)\n", + "# polynomial\n", + "step_poly = dbi.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation,d=d, n=3)\n", + "print('polynomial_approximation step:', step_poly)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The minimum for cost function in the tested range is: 0.02021181818181818\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the results\n", + "plt.figure()\n", + "plt.plot(s_space, potential)\n", + "plt.xlabel('s')\n", + "plt.axvline(x=step_grid, color='r', linestyle='-',label='grid_search')\n", + "plt.axvline(x=step_hyperopt, color='g', linestyle='--',label='hyperopt')\n", + "plt.axvline(x=step_poly, color='m', linestyle='-.',label='polynomial')\n", + "plt.title('First DBI step')\n", + "plt.ylabel('Least squares cost function')\n", + "plt.legend()\n", + "plt.figure()\n", + "plt.plot(s_space, off_diagonal_norm_diff)\n", + "plt.axvline(x=step_grid, color='r', linestyle='-',label='grid_search')\n", + "plt.axvline(x=step_hyperopt, color='g', linestyle='--',label='hyperopt')\n", + "plt.axvline(x=step_poly, color='m', linestyle='-.',label='polynomial')\n", + "plt.ylabel(r'$||\\sigma(H_0)||-\\sigma(H_k)||$')\n", + "plt.xlabel('s')\n", + "plt.title('First DBI step')\n", + "plt.legend()\n", + "print('The minimum for cost function in the tested range is:', step_grid)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Comparison of the least-squares cost function with the original cost function using the polynomial scheduling method" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "d = np.diag(np.linspace(1,2**nqubits,2**nqubits))\n", + "off_diagonal_norm_diff = [dbi.off_diagonal_norm]\n", + "off_diagonal_norm_diff_least_squares = [dbi.off_diagonal_norm]\n", + "iters = 100\n", + "dbi_ls = deepcopy(dbi)\n", + "cost = DoubleBracketCostFunction.off_diagonal_norm\n", + "dbi_od = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)\n", + "for _ in range(iters):\n", + " step_poly = dbi_od.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation, d=d, n=3)\n", + " dbi_od(step_poly,d=d)\n", + " step_poly = dbi_ls.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation, d=d, n=3)\n", + " dbi_ls(step_poly,d=d)\n", + " off_diagonal_norm_diff.append(dbi_od.off_diagonal_norm)\n", + " off_diagonal_norm_diff_least_squares.append(dbi_ls.off_diagonal_norm)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAGwCAYAAABVdURTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAABo2ElEQVR4nO3dd3hUddrG8e+kTXpCekICCSW0UAWpUhRUVBRx7QVWF9dVVNbXsqtbdFUQFdaOrgVZGzZwsYDUIIL03jsESAjpvZ/3j5MMRCAmkGQmk/tzXXMlc+bMmSdnI7n3Vy2GYRiIiIiIOAkXexcgIiIiUp8UbkRERMSpKNyIiIiIU1G4EREREaeicCMiIiJOReFGREREnIrCjYiIiDgVN3sX0NgqKio4fvw4fn5+WCwWe5cjIiIitWAYBrm5uURFReHiUnPbTLMLN8ePHycmJsbeZYiIiMh5SEpKIjo6usZzml248fPzA8yb4+/vb+dqREREpDZycnKIiYmx/R2vSbMLN1VdUf7+/go3IiIiTUxthpRoQLGIiIg4FYUbERERcSoKNyIiIuJUmt2YGxGR5qK8vJzS0lJ7lyFSK+7u7ri6utbLtRRuREScjGEYpKSkkJWVZe9SROokMDCQiIiIC16HTuFGRMTJVAWbsLAwvL29tWCpODzDMCgoKCA1NRWAyMjIC7qewo2IiBMpLy+3BZvg4GB7lyNSa15eXgCkpqYSFhZ2QV1UGlAsIuJEqsbYeHt727kSkbqr+r290LFiCjciIk5IXVHSFNXX763CjYiIiDgVhRsRERFxKgo3IiLS5BQUFHDDDTfg7++PxWIhKyvrrMdqY+jQoUycONH2PDY2lldeeaVB6m5o48aNY/To0fYuw+4UbupJUWE+yYf3kHb8sL1LERFpspKSkrjnnnuIiorCw8OD1q1b8/DDD5Oenl7tvJkzZ7J8+XJWrlxJcnIyAQEBZz12PtauXcu9995bHz+O2InCTT3Z+Mk/iJzRh32z/2nvUkREmqQDBw7Qu3dv9uzZw2effca+fft4++23Wbx4Mf379ycjI8N27v79++nUqRMJCQm2Rd/Odux8hIaGarZZHTnaStgKN/XExScIAPeiTDtXIiJSnWEYFJSU2eVhGEat63zggQfw8PBgwYIFDBkyhFatWjFy5EgWLVrEsWPHeOqppwCzG2nq1Kn89NNPWCwWhg4detZjZ5Ofn89dd92Fr68vkZGRTJ069Yxzft0tNW3aNLp27YqPjw8xMTHcf//95OXlVXvPu+++S0xMDN7e3lx//fVMmzaNwMDAaudMnz6dtm3b4uHhQYcOHfjoo4+qvW6xWHjvvfe4/vrr8fb2pn379sydO9f2enl5Offccw9xcXF4eXnRoUMHXn311VrfX4APP/yQwMBAfvzxRzp16oSvry9XXnklycnJtnMqKir417/+RXR0NFarlR49ejB//nzb64cOHcJisfDFF18wdOhQPD09+fjjj21dYpMmTSI8PJzAwECeeeYZysrKeOyxxwgKCiI6OpoPPvigTjWfDy3iV0/c/EIB8CjJsm8hIiK/UlhaTud//GiXz97xryvw9vjtPzUZGRn8+OOPPP/887bF3KpERERw++238/nnn/PWW28xe/Zs/vKXv7Bt2zZmz56Nh4cHwFmP/dpjjz3G0qVLmTNnDhERETz55JOsX7+eHj16nLM2FxcXXnvtNWJjYzl48CD3338/jz/+OG+99RYAK1as4L777mPKlClce+21LFq0iL///e/VrjFnzhwefvhhXnnlFYYPH853333H73//e6Kjoxk2bJjtvGeeeYYXX3yRl156iddff53bb7+dw4cPExQUREVFBdHR0XzxxReEhISwcuVK7r33XiIjI7npppt+8x5XKSgo4OWXX+ajjz7CxcWFO+64g0cffZRPPvkEgFdffZWpU6fyzjvv0LNnTz744AOuvfZatm/fTvv27W3XeeKJJ5g6dSozZszAarWybNkylixZQnR0ND/99BMrVqzgnnvu4ZdffmHw4MGsXr2azz//nPvuu48RI0YQExNT65rrSi039cTT3ww33mXZdq5ERKTp2bt3L4Zh0KlTp7O+3qlTJzIzMzl58iRBQUF4e3vj4eFBREQEQUFBZz32a3l5ebz//vu8/PLLjBgxgq5duzJz5kzKy8trrG3ixIkMGzaMuLg4Lr30Up599lm++OIL2+uvv/46I0eO5NFHHyU+Pp7777+fkSNHVrvGyy+/zLhx47j//vuJj4/nkUceYcyYMbz88svVzhs3bhy33nor7dq1Y9KkSeTn57NmzRrA3FjymWeeoU+fPsTFxXH77bczbty4arXURmlpKW+//Ta9e/emV69eTJgwgcWLF1er9YknnuCWW26hQ4cOTJkyhR49epwxyHrixImMGTOGuLg4oqKiAAgKCuK1116jQ4cO3H333XTo0IGCggKefPJJ2rdvz1//+lc8PDxYsWJFnWquK7Xc1BPvQDPc+FYo3IiIY/Fyd2XHv66w22fXh6rurdqOo1m+fHm1gPHOO++QkJBASUkJ/fv3tx0PCgqiQ4cONV5r6dKlTJo0iR07dpCTk0NZWRlFRUXk5+fj4+PD7t27uf7666u95+KLL+a7776zPd+5c+cZg5QHDhx4RrdSt27dbN/7+Pjg5+dn228J4O233+a9997j8OHDFBYWUlJSUmOr09l4e3vTtm1b2/PIyEjbZ+Tk5HD8+HEGDhx4Rq2bN2+udqx3795nXLtLly64uJxqNwkPDychIcH23NXVleDg4Go/U0NQuKknfkHhAAQYuZSXV+DqqkYxEXEMFoulVl1D9tSuXTssFgs7duw461TmXbt20aJFC0JCQmp1vd69e7Np0ybb8/DwcPbv31/nug4fPsxVV13Ffffdx7PPPktQUBA///wz99xzj20QrWEYZ4Sus401Ots5vz7m7u5+xnsqKioA+OKLL/jzn//M1KlT6d+/P35+frz00kusXr26Tj/T2T7j1/XWplYfH59aXbumn6mh6C9wPQkINsONp6WUrOws+xYjItLEBAcHM2LECN566y0KCwurvZaSksInn3zCzTffXOuWGy8vL9q1a2d7+Pn50a5dO9zd3Vm1apXtvMzMTPbs2XPO66xbt46ysjKmTp1Kv379iI+P5/jx49XO6dixo63r6PT3na5Tp078/PPP1Y6tXLnynN1wZ7N8+XIGDBjA/fffT8+ePWnXrt15Bbaa+Pv7ExUVdcG12ptjR/kmxN3Tj2LcsVJKTsYJgs/S3ysiIuf2xhtvMGDAAK644gqee+454uLi2L59O4899hgtW7bk+eefv6Dr+/r6cs899/DYY48RHBxMeHg4Tz31VLVulF9r27YtZWVlvP7664waNYoVK1bw9ttvVzvnwQcfZPDgwUybNo1Ro0axZMkS5s2bVy2IPfbYY9x000306tWLyy67jG+//ZbZs2ezaNGiWtffrl07/vvf//Ljjz8SFxfHRx99xNq1a4mLi6v7zajBY489xj//+U/atm1Ljx49mDFjBps2bbINOG4K1HJTXywWci1+AORmNmxfooiIM2rfvj3r1q2jbdu23HzzzbRt25Z7772XYcOG8csvv5x1kHBdvfTSSwwePJhrr72W4cOHM2jQIC666KJznt+jRw+mTZvGlClTSEhI4JNPPmHy5MnVzhk4cCBvv/0206ZNo3v37syfP58///nPeHp62s4ZPXo0r776Ki+99BJdunThnXfeYcaMGeecsn429913H2PGjOHmm2+mb9++pKenc//999f5HvyWhx56iP/7v//j//7v/+jatSvz589n7ty51WZKOTqLUZdFCJxATk4OAQEBZGdn4+/vX6/XPvRcD2LLDrJm0HtcPPzGer22iEhtFBUVcfDgQeLi4qr9cZXGNX78eHbt2sXy5cvtXUqTUtPvb13+fqtbqh4VugVCGRTnpNm7FBERaURV08t9fHyYN28eM2fOtK2DI41P4aYelVoDoQjK8hRuRESakzVr1vDiiy+Sm5tLmzZteO211/jDH/5g77KaLYWbelTuGQTZQEH6b54rIiLOo64L6UnD0oDiemTxNge7uRRqfykRERF7UbipR66+5uJS7sUKNyIiIvaicFOP3P3McOOp/aVERETsRuGmHnkFmPtL+SjciIiI2I3CTT3yCTS3YPA3sqmoaFbLB4mIiDgMhZt65BcUBkAgeWQXltq5GhERkeZJ4aYeWf3NbikvSwkZWeqaEhGpi3Hjxp11R/DGYrFY+Oabb+z2+VJ/FG7qk4cvpZVLB+VmnrBzMSIi0lyUlJTYuwSHonBTnywWcl3M/S7yFW5EROrVjh07uOqqq/D19SU8PJw777yTtLRTK8LPnz+fQYMGERgYSHBwMNdccw379++3vV5SUsKECROIjIzE09OT2NhY2yaYsbGxAFx//fVYLBbb81+r6RoAe/fuZfDgwXh6etK5c2cWLlxYrUUoMTERi8VCVlaW7T2bNm3CYrFw6NAhANLT07n11luJjo7G29ubrl278tlnn1WrY+jQoUyYMIFHHnmEkJAQRowYUat79NVXX9G1a1e8vLwIDg5m+PDh5Ofn1+l/h6ZA4aaeFbgGAFCUc9LOlYiIVDIMKMm3z6Oe9mZOTk5myJAh9OjRg3Xr1jF//nxOnDjBTTfdZDsnPz+fRx55hLVr17J48WJcXFy4/vrrqaioAOC1115j7ty5fPHFF+zevZuPP/7YFmLWrl0LwIwZM0hOTrY9/7WarlFRUcGYMWNwdXVl1apVvP322zzxxBN1/lmLioq46KKL+O6779i2bRv33nsvd955J6tXr6523syZM3Fzc2PFihW88847v3mPkpOTufXWW7n77rvZuXMniYmJjBkzBmfcP1vbL9SzYo9AKIUSbZ4pIo6itAAmRdnns588Dh4+F3yZ6dOn06tXLyZNmmQ79sEHHxATE8OePXuIj4/nhhtuqPae999/n7CwMHbs2EFCQgJHjhyhffv2DBo0CIvFQuvWrW3nhoaaYyYDAwOJiIg4Zx01XWPRokXs3LmTQ4cOER0dDcCkSZMYOXJknX7Wli1b8uijj9qeP/jgg8yfP58vv/ySvn372o63a9eOF1980fb8H//4R433KC8vj7KyMsaMGWOru2vXrnWqralQy009K7W2AMDI1/5SIiL1Zf369SxduhRfX1/bo2PHjgC2rqf9+/dz22230aZNG/z9/YmLiwPMQALmgOVNmzbRoUMHHnroIRYsWFDnOmq6xs6dO2nVqpUt2AD079+/zp9RXl7O888/T7du3QgODsbX15cFCxbYfo4qvXv3rvb8t+5R9+7dueyyy+jatSs33ngj7777LpmZzrmivlpu6pnhZYYbCjPsW4iISBV3b7MFxV6fXQ8qKioYNWoUU6ZMOeO1yMhIAEaNGkVMTAzvvvsuUVFRVFRUkJCQYBts26tXLw4ePMi8efNYtGgRN910E8OHD+err76qdR01XeNs3TsWi6XacxcXs03h9HNLS6svHTJ16lT+/e9/88orr9C1a1d8fHyYOHHiGYOGfXyqt4j91j1ydXVl4cKFrFy5kgULFvD666/z1FNPsXr1alsQdBYKN/XM4hMMgGuRwo2IOAiLpV66huypV69efP3118TGxuLmduafrvT0dHbu3Mk777zDJZdcAsDPP/98xnn+/v7cfPPN3Hzzzfzud7/jyiuvJCMjg6CgINzd3SkvL//NWs51jc6dO3PkyBGOHz9OVJTZDfjLL79Ue29V91dycjItWpj/Z3jTpk3Vzlm+fDnXXXcdd9xxB2CGlr1799KpU6cLukdghq2BAwcycOBA/vGPf9C6dWvmzJnDI4888ps/d1Oibql65uZr/uJaS7LsW4iISBOUnZ3Npk2bqj2OHDnCAw88QEZGBrfeeitr1qzhwIEDLFiwgLvvvpvy8nJatGhBcHAw//nPf9i3bx9Lliw54w/2v//9b2bNmsWuXbvYs2cPX375JREREQQGBgLmjKnFixeTkpJyzu6amq4xfPhwOnTowF133cXmzZtZvnw5Tz31VLX3t2vXjpiYGJ5++mn27NnD999/z9SpU884p6qFZefOnfzxj38kJSXlN+/db92j1atXM2nSJNatW8eRI0eYPXs2J0+e/M3Q1BQ5VLiZPn063bp1w9/fH39/f/r378+8efNsr48bNw6LxVLt0a9fPztWfCZPf22eKSJyvhITE+nZs2e1xz/+8Q+ioqJYsWIF5eXlXHHFFSQkJPDwww8TEBCAi4sLLi4uzJo1i/Xr15OQkMCf//xnXnrppWrX9vX1ZcqUKfTu3Zs+ffpw6NAhfvjhB1tX0dSpU1m4cCExMTH07NnzrPXVdA0XFxfmzJlDcXExF198MX/4wx94/vnnq73f3d2dzz77jF27dtG9e3emTJnCc889V+2cv//97/Tq1YsrrriCoUOHEhERUavFDX/rHvn7+/PTTz9x1VVXER8fz9/+9jemTp1a5wHPTYHFcKA5YN9++y2urq60a9cOMKe5vfTSS2zcuJEuXbowbtw4Tpw4wYwZM2zv8fDwICgoqNafkZOTQ0BAANnZ2fj7+9f7z5C+8TuC/3c72yti6fzMpjP6W0VEGlJRUREHDx4kLi4OT09Pe5cjmF1Bc+bMsevqy01FTb+/dfn77VBjbkaNGlXt+fPPP8/06dNZtWoVXbp0AcBqtdY4Te/XiouLKS4utj3Pycmpn2LPwbeFub9UgCWPnMIyArzdG/TzREREpDqH6pY6XXl5ObNmzSI/P7/aVLrExETCwsKIj49n/PjxpKam1nidyZMnExAQYHvExMQ0aN1V+0sFkUt6fvFvnC0iIiL1zaFabgC2bt1K//79KSoqwtfXlzlz5tC5c2cARo4cyY033kjr1q05ePAgf//737n00ktZv349Vqv1rNf761//Wm1QWU5OTsMGHG+zi8zbUkxmdg6E+jbcZ4mIiMNzoNEfzYbDhZsOHTqwadMmsrKy+Prrrxk7dizLli2jc+fO3HzzzbbzEhIS6N27N61bt+b7779nzJgxZ72e1Wo9Z/BpEFZ/ynDFjXJyM1MBO60KKiIi0kw5XLeUh4cH7dq1o3fv3kyePJnu3bvz6quvnvXcyMhIWrduzd69exu5yhpYLORV7i9VmF1zl5mISENRa4E0RfX1e+tw4ebXDMOoNiD4dOnp6SQlJdlWp3QURW5muNH+UiLS2NzdzUkMBQUFdq5EpO6qfm+rfo/Pl0N1Sz355JOMHDmSmJgYcnNzmTVrFomJicyfP5+8vDyefvppbrjhBiIjIzl06BBPPvkkISEhXH/99fYuvZoSjxZQfJDSXO0MLiKNy9XVlcDAQNtkC29vby1JIQ7PMAwKCgpITU0lMDAQV1fXC7qeQ4WbEydOcOedd5KcnExAQADdunVj/vz5jBgxgsLCQrZu3cp///tfsrKyiIyMZNiwYXz++ef4+fnZu/Rqyj0DIReMAm2eKSKNr2q5jN+aTSriaH5rV/bacqhw8/7775/zNS8vL3788cdGrOb8GV7m/lIuhc6526qIODaLxUJkZCRhYWFnbMoo4qjc3d0vuMWmikOFG2fh4mtuweBWrHAjIvbj6upab38sRJoShx9Q3BR5+JktN56lWfYtREREpBlSuGkAngHmKsXeZdmajikiItLIFG4agE9gOACB5JBbXGbnakRERJoXhZsGULW/VAtLHhl5JXauRkREpHlRuGkIXi0AaEEu6fkKNyIiIo1J4aYheJsDin0sxWTl5Nq5GBERkeZF4aYheAZQXnlr87NO2LkYERGR5kXhpiFYLBTYNs/UFgwiIiKNSeGmgRR5BALaPFNERKSxKdw0kLLKcFORr3AjIiLSmBRuGki5VxAARoG2YBAREWlMCjcNxFI5Y8qtSDuDi4iINCaFmwbiVrl5pkdJln0LERERaWYUbhpI1SrFnqXaX0pERKQxKdw0EK9As+UmwMghv6TcztWIiIg0Hwo3DcTqFwZAoCWP1JwiO1cjIiLSfCjcNJTKAcVB5HIko8DOxYiIiDQfCjcNxducCt7CksvhdIUbERGRxqJw01Aqw42vpYikk1rrRkREpLEo3DQUawAVFlcAMk6m2LkYERGR5kPhpqG4uFDi0xIAI32fnYsRERFpPhRuGpAR1gmAwLx9lFdorRsREZHGoHDTgDwjuwDQzkjieFahnasRERFpHhRuGpAlvDMA7V2Ocig9387ViIiINA8KNw0prCMAHSxJHEpTuBEREWkMCjcNKbg9FbgSYCkgI/mQvasRERFpFhRuGpK7J7k+rQAoP7HLzsWIiIg0Dwo3DawkKB4A76zddq5ERESkeVC4aWAekQkAhBQeoELTwUVERBqcwk0D843pCkA7kkjR7uAiIiINTuGmgblGVE4HtxzlUFqunasRERFxfgo3DS2oDaW442MpJu2otmEQERFpaAo3Dc3VnXSv1gAUH99u52JEREScn8JNI8gPaAeAW5qmg4uIiDQ0hZtGYAk1x90E5KpbSkREpKEp3DQC72hzOnhEySEMQ9PBRUREGpLCTSMIiusBQFuOcTK7wL7FiIiIODmFm0bgERJHER5YLaUkH9ph73JEREScmsJNY3Bx4bi7OWMq78hWOxcjIiLi3Bwq3EyfPp1u3brh7++Pv78//fv3Z968ebbXDcPg6aefJioqCi8vL4YOHcr27U1jenWWrzljykhVy42IiEhDcqhwEx0dzQsvvMC6detYt24dl156Kdddd50twLz44otMmzaNN954g7Vr1xIREcGIESPIzXX8lX9LgzsC4JW1186ViIiIODeHCjejRo3iqquuIj4+nvj4eJ5//nl8fX1ZtWoVhmHwyiuv8NRTTzFmzBgSEhKYOXMmBQUFfPrpp/Yu/Td5RJrTwUMKD9i5EhEREefmUOHmdOXl5cyaNYv8/Hz69+/PwYMHSUlJ4fLLL7edY7VaGTJkCCtXrjzndYqLi8nJyan2sIcWsd0BiCo7hlFWbJcaREREmgOHCzdbt27F19cXq9XKfffdx5w5c+jcuTMpKSkAhIeHVzs/PDzc9trZTJ48mYCAANsjJiamQes/l4iYtuQYXrhbyslK2mmXGkRERJoDhws3HTp0YNOmTaxatYo//elPjB07lh07Tg3CtVgs1c43DOOMY6f761//SnZ2tu2RlJTUYLXXxNPDjcMurQDIPLTZLjWIiIg0B272LuDXPDw8aNfOnFnUu3dv1q5dy6uvvsoTTzwBQEpKCpGRkbbzU1NTz2jNOZ3VasVqtTZs0bV00qsNFOym+Pg2e5ciIiLitByu5ebXDMOguLiYuLg4IiIiWLhwoe21kpISli1bxoABA+xYYe3lBVbOmDq5xc6ViIiIOC+Harl58sknGTlyJDExMeTm5jJr1iwSExOZP38+FouFiRMnMmnSJNq3b0/79u2ZNGkS3t7e3HbbbfYuvVbKovvCcQjP3oxRVoLFzcPeJYmIiDgdhwo3J06c4M477yQ5OZmAgAC6devG/PnzGTFiBACPP/44hYWF3H///WRmZtK3b18WLFiAn5+fnSuvnUEDh5C12odA8tm6bjld+11m75JEREScjsVoZttU5+TkEBAQQHZ2Nv7+/o3++TunXUOnnOV85n83tz7y70b/fBERkaaoLn+/HX7MjbOJ7DEcgIjM9Ww8kmnnakRERJyPwk0jC+x0KQB9XHYzfcluO1cjIiLifBRuGlt4F8qtAfhaijixezU7k+2zYrKIiIizUrhpbC6uuMYOBKCvy07eXLrPzgWJiIg4F4Ube4gdBEA/l518vzWZ/Sfz7FyQiIiI81C4sYfWZstNf7c9uBjlTE/cb+eCREREnIfCjT1EdAVrAF5GAZ0th/lm4zEy8kvsXZWIiIhTULixBxdXaG1uGXGl717KKgx1TYmIiNQThRt7qRxU3N9lJwBHMwvsWY2IiIjTULixl8pBxZ1Kt+NCBUczCu1ckIiIiHNQuLGXiG5g9cerIp/OlkMkqeVGRESkXijc2IuLK7TqD5hTwo9mquVGRESkPijc2FNl11RfhRsREZF6o3BjT7Zws4uUrHzKK5rVBu0iIiINQuHGniK6YVj98bcU0ME4SEpOkb0rEhERafIUbuzJ1Q1LZevNQJdtHM3QoGIREZELpXBjb22GAma4SdK4GxERkQumcGNvcUMAuNhlN8lpGXYuRkREpOlTuLG30A7ke4RgtZTifnydvasRERFp8hRu7M1iISPc3GcqIn2VnYsRERFp+hRuHEBZ7GAA4vPX27kSERGRpk/hxgH4dRwOQMeK/ZTladyNiIjIhVC4cQBBkbHsM1riYjHI2rHY3uWIiIg0aQo3DsDFxcIWjx4AlO1bat9iREREmjiFGwdxOOBiAHyO/WznSkRERJo2hRsHkRPRl3LDgl/+YchKsnc5IiIiTZbCjYMIDQlls9HWfHJwmX2LERERacIUbhxEdAtvfq5IMJ8cSLRrLSIiIk2Zwo2DiGnhxYryruaTA4lgGHatR0REpKlSuHEQ0S282Wi0o8CwQv5JSN1h75JERESaJIUbBxHi64GLu5U1FR3NA+qaEhEROS8KNw7CYrFUH3ezZ759CxIREWmiFG4cSHQLL36s6G0+OfQz5KXatyAREZEmSOHGgUS38CLJCCfFpxMYFbBzrr1LEhERaXIUbhxITAtvAFZ7DzEPbJtjx2pERESaJoUbBxJdGW7mGf3MA4dXQG6KHSsSERFpehRuHEh0Cy8ANub4QXQfwIAd/7NvUSIiIk2Mwo0DqQo3J3KKKes02jy4bbb9ChIREWmCFG4cSJCPB94ergAcb3mFeTBpFWQfs2NVIiIiTYvCjQMx17oxW28OlQRCq/7mCzu+sVtNIiIiTY3CjYOpGlR8NLMQulxvHtyuWVMiIiK15VDhZvLkyfTp0wc/Pz/CwsIYPXo0u3fvrnbOuHHjsFgs1R79+vWzU8X1L6ay5eZoZgF0vg6wwNG1kHXEvoWJiIg0EQ4VbpYtW8YDDzzAqlWrWLhwIWVlZVx++eXk5+dXO+/KK68kOTnZ9vjhhx/sVHH9iwkyW24OpeeDXwTEDjJfUOuNiIhIrbjZu4DTzZ9ffT+lGTNmEBYWxvr16xk8eLDtuNVqJSIiorHLaxSdI/0B2HI02zzQZTQcWm6Gm4EP268wERGRJsKhWm5+LTvb/AMfFBRU7XhiYiJhYWHEx8czfvx4UlPPvQdTcXExOTk51R6OrGt0ABaLOeYmLa8YOl0HFhc4vhHS99u7PBEREYfnsOHGMAweeeQRBg0aREJCgu34yJEj+eSTT1iyZAlTp05l7dq1XHrppRQXF5/1OpMnTyYgIMD2iImJaawf4bz4ebrTLtQXgM1JWeAbCm2GmS9unmW/wkRERJoIhw03EyZMYMuWLXz22WfVjt98881cffXVJCQkMGrUKObNm8eePXv4/vvvz3qdv/71r2RnZ9seSUlJjVH+BekeEwhUhhuAHreZXzd/BhUVdqlJRESkqXDIcPPggw8yd+5cli5dSnR0dI3nRkZG0rp1a/bu3XvW161WK/7+/tUejq5HZbjZWBVuOl4N1gDIToLDP9utLhERkabAocKNYRhMmDCB2bNns2TJEuLi4n7zPenp6SQlJREZGdkIFTaOHqe13BiGAe5ekFC55s2mT+1XmIiISBPgUOHmgQce4OOPP+bTTz/Fz8+PlJQUUlJSKCwsBCAvL49HH32UX375hUOHDpGYmMioUaMICQnh+uuvt3P19adDhB9WNxdyiso4lF5gHuxxu/l1x1wozrNfcSIiIg7OocLN9OnTyc7OZujQoURGRtoen3/+OQCurq5s3bqV6667jvj4eMaOHUt8fDy//PILfn5+dq6+/ri7upDQMgCATUmZ5sHoPhDUFkrztVO4iIhIDRxqnRvDMGp83cvLix9//LGRqrGv7tGBrD+cyeakbK7vGQ0WizmweMmzZtdUz9vtXaKIiIhDcqiWGzmle0xVy03WaQdvASzmoOLMQ/YoS0RExOEp3DionjEtANhxPIfisnLzYEA0tBlifq81b0RERM6qTt1ScXFxWCyWOn/IxIkTeeihh+r8vuYsJsiLFt7uZBaUsis517b2DT1uhwOJZtfU4MfBRflURETkdHUKNx9++OF5fUhsbOx5va85s1gsdI8JJHH3STYfzToVbjpeAx5+kHUYjvwCsQPtWqeIiIijqVO4GTJkSEPVIWfRozLcbDqSxV39Kw96eJubaW78CNbPULgRERH5FfVpOLCq1ppNR7Oqv9DnD+bXrV9ByrZGrUlERMTRKdw4sO7RgQAcOJlPdmHpqReiekCXMYABi5+xR2kiIiIOSwOKHViQjwetg705nF7AlqNZXNI+9NSLl/4Nds6FvQvg4HKIu8R+hYqIiDgQDSh2cN2jAzmcXsDmpF+Fm+C2cNE4WPseLPon/GGxudCfiIhIM6cBxQ6ue0wgczcfZ1NS9pkvDn4cNn0Gx9abrTidr2v8AkVERBzMBY25KS0tJSkpid27d5ORkVFfNclpqnYI31S1Q/jp/MJhwATz+8X/gvJSREREmrs6h5u8vDzeeecdhg4dSkBAALGxsXTq1InQ0FBat27N+PHjWbt2bUPU2ix1ifLHzcVCWl4xRzMLzzyh/wTwDoH0feb0cBERkWauTuHm3//+N7Gxsbz77rtceumlzJ49m02bNrFnzx5++eUX/vnPf1JWVsaIESO48sor2bt3b0PV3Wx4urvSs1UgAMv2nDzLCf4w5HHz+8QXoDi38YoTERFxQBbjt7biPs2NN97IP/7xD7p27VrjecXFxbz//vt4eHjwhz/84YKLrE85OTkEBASQnZ2Nv7+/vcuplTeX7uOlH3dzWccw3h/X58wTykrgzT7mZpq974FrpjV6jSIiIg2pLn+/6xRunEFTDDc7k3MY+epyPN1d2PSPy/F0dz3zpAPL4L/Xmt/fNffUBpsiIiJOoC5/v+ttEb8ZM2bU16XkVzpG+BEZ4ElRaQWrDqSf/aQ2Q8xWG4C5E6A4r/EKFBERcSD1Fm5mz57N0qVLbc8LCwu5/fbb6+vyzZrFYmFohzAAEnefZdxNlRHPQEAryDpirn0jIiLSDNVbuPn444956qmn2LVrF3v37uWSSy5h6NCh9XX5Zm9YB3MBvyW7Us+cEl7F6gfXvWF+v/Y9OPhTI1UnIiLiOOq0iN/ZPPLII/To0YMePXrwwQcfcNttt2EYBh988AE9e/asjxoFGNguBA9XF45kFLD/ZD7twnzPfmKbIdD7blj3AfzvAfjTL2A9x7kiIiJO6IJbboYMGcLhw4d59tlnufHGGzl8+DBRUVEsWLCA77//vj5qFMDH6kbfNkEAJO5OrfnkEf861T214KlGqE5ERMRxXHC4ue666/j73//Ol19+ydatWzl69ChPP/00ISEhLFq0qD5qlErDKsfdLNn1G+HG1j1lgfUfwtavGrw2ERERR1HnqeCGYZzXzuCOoilOBa9yKC2foS8n4u5qYcPfR+Dn6V7zG5Y8Bz+9BB6+cG8ihLRvlDpFRETqW4NOBff19WXgwIE89NBDzJw5k23btlFRUXHexUrtxYb4EBfiQ2m5wYp9ab/9hqF/hdhLoCQPvhwHpWfZvkFERMTJ1DncvPTSS3Tq1Inly5czfvx4unfvjp+fH/3792fChAnMmDGDzZs3N0StQh26pgBcXOGG98AnFE5sg3mPN3B1IiIi9ndBKxQXFxfj5eXFk08+SUZGBhs2bGDLli0UFxdTXl5en3XWm6bcLQWwfO9J7nx/DaF+VtY8eVntuggPJMJ/RwMGXP8f6H5zA1cpIiJSv+ry9/uCpoJbrVYAbrrpJrp16wZAeXk527dvv5DLSg0ujgvC28OVk7nFbD+eQ0LLgN9+U5uhMOQJWPYCfDcRIhIgvEtDlyoiImIX9baIXxVXV1db0JH6Z3VzZWC7EKCWXVNVhjxuhpzSAvjsVijIaJgCRURE7Kzew400vOGdzHE3324+fu7Vin/NxRV+NwNaxELWYfhyLJSXNlyRIiIidlLncDN+/Hjefvtt1q1bR3FxMUCTnhreFI3sGonVzYW9qXlsPppd+zd6B8Etn5lTww/+BAv+1nBFioiI2Emdw83u3bt54oknuPjii/Hz8wPgmWee4Y033mDlypUUFBTUe5FSnb+nO1d1jQTgi3VJdXtzeGe4/h3z+9Vvw4aP6rk6ERER+zrv2VJ79+5l/fr1bNiwgfXr17Nx40aysrJwdXUlPj7eYQcVN/XZUlVW7k/jtndX42d1Y81Tw/HycK3bBRKnQOIkcHGHcd9Bq34NU6iIiEg9aJTZUu3bt6d9+/bccssttmMHDx5k3bp1bNy48XwvK7XULy6YmCAvkjIKmbctmTG9out2gcGPmWvf7JwLn94EY7+FyO4NU6yIiEgjqlO31JEjR2p8PS4ujhtvvJFJkyYBcOzYsfOvTGrk4mLhxotigPPomjIvANe/DTH9oCjbXAfnhGO2tomIiNRFncJNnz59GD9+PGvWrDnnOdnZ2bz77rskJCQwe/bsCy5Qzu2Gi6KxWGDVgQwOp+fX/QIePnD7l9DyIijMgP9eByf31H+hIiIijahO3VI7d+5k0qRJXHnllbi7u9O7d2+ioqLw9PQkMzOTHTt2sH37dnr37s1LL73EyJEjG6puAVoGejGoXQjL96bx1fqj/N/lHep+EU9/uONrmHktpGyBmaPg9z9AcNv6L1hERKQRnNeA4qKiIn744QeWL1/OoUOHKCwsJCQkhJ49e3LFFVeQkJDQELXWC2cZUFzl283HefCzjUQGePLzE5fi6nKe0/Lz02HmNZC6A/yj4a7/QUi7+i1WRETkPNXl7/d5z5bKyclpkuHA2cJNcVk5fSctJquglA9/34ehlRtrnpe8VPjwakjbA94hcMdXENWz/ooVERE5T3X5+33eKxS3aNGCr7/++nzfLvXE6ubK6B4tAfhy3dELu5hvGIz7ASJ7QEEafHiNuemmiIhIE3Le4cYwDKZPn07fvn3p168fEyZMYPXq1fVZm9TSjb3NaeALdqSQnld8YRfzDTXXvYkbAiV58MmNsH1OPVQpIiLSOC5ob6nNmzdz8cUXM3ToUHbv3s2QIUP485//XF+1SS11iQqgW3QApeUGM385fOEXtPqZs6g6XwflJfDl72H1O3B+PZgiIiKN6oLCzaeffsrrr7/OCy+8wMKFC1m7di1z585l6tSp9VWf1NIfB5uzm2auPER+cdmFX9DNam602ftuwIB5j8O3D0NZyYVfW0REpAGdd7gJDg4mJiam2rGuXbvy2muv8fbbb5/XNSdPnkyfPn3w8/MjLCyM0aNHs3v37mrnGIbB008/TVRUFF5eXgwdOtRht3poTFcmRBAb7E12YSmz1p7Hon5n4+IKV0+DEc8CFtgwE/57LeSdrJ/ri4iINIDzDjfdu3fn/fffP+N4u3btSEo6vz+uy5Yt44EHHmDVqlUsXLiQsrIyLr/8cvLzTy1Q9+KLLzJt2jTeeOMN1q5dS0REBCNGjCA3N/d8fxSn4Opi4d7K1pv3lh+gpKyifi5sscDAh+C2L8DqD0d+gXeHQfKW+rm+iIhIPTvvqeCrVq1i2LBhXH/99dx///1069aNwsJCHn/8cdasWcPOnTsvuLiTJ08SFhbGsmXLGDx4MIZhEBUVxcSJE3niiScAKC4uJjw8nClTpvDHP/7xjGsUFxdTXHxqkG1OTg4xMTFOMxX8dEWl5Vzy4lJO5hbz0u+6cWPvmN9+U12c3AOf3QIZ+8HdG659Hbr+rn4/Q0RE5CwaZSp4v379WLVqFcePH2fo0KG0aNGCqKgovvrqq3obc5OdnQ1AUFAQYG7MmZKSwuWXX247x2q1MmTIEFauXHnWa0yePJmAgADb49ddac7E092VewbFAfD2sv1UVNTzAODQeBi/GNpeCqUF8PU9MO8JKC+t388RERG5AOfdcnO61NRU1q9fT0VFBX379iUkJOSCCzMMg+uuu47MzEyWL18OwMqVKxk4cCDHjh0jKirKdu69997L4cOH+fHHH8+4TnNquQHILSplwAtLyC0q4z93XsTlXSLq/0MqymHp87C8MsTG9IObZoJfA3yWiIgIjdRyc7qwsDBGjhzJ1VdfXS/BBmDChAls2bKFzz777IzXLJbqWwwYhnHGsSpWqxV/f/9qD2fm5+nOnf1aA/BW4n7qIbueycUVLvsH3PKpOQ4naRW8MxgOraj/zxIREamjegk39e3BBx9k7ty5LF26lOjoaNvxiAizZSAlJaXa+ampqYSHhzdqjY7s9wPj8HBzYVNSFqsPZjTcB3W8Gu5NhLDOkHfC3Jtq6WQor4ep6CIiIuepTuEmLi6ONm3a1Pnx2muv1er6hmEwYcIEZs+ezZIlS4iLizvj8yMiIli4cKHtWElJCcuWLWPAgAF1+VGcWqiflRsvMkPhK4v2NEzrTZXgtvCHRdD9NjAqYNkLZsjJqqfp6CIiInXkVpeTP/zww/P6kNjY2Fqd98ADD/Dpp5/yv//9Dz8/P1sLTUBAAF5eXlgsFiZOnMikSZNo37497du3Z9KkSXh7e3PbbbedV23O6k9D2/Ll+qOsOpDBwh0nGmbsTRUPH7h+ujnQ+Ls/m9PF3x5ozqbqfF3Dfa6IiMhZ1MuA4vpyrnEzM2bMYNy4cYDZuvPMM8/wzjvvkJmZSd++fXnzzTdJSEio1Wc4267gNXlx/i7eStxPXIgPP04cjIdbI/RCZhw0Z1EdW28+73UXXDEZrL4N/9kiIuK06vL326HCTWNoTuEmt6iUYS8nkpZXwt+v6WybJt7gykvN2VQ/vwIYENQWbngPWvZqnM8XERGn02DhJi4u7pytKzWZOHEiDz30UJ3f1xCaU7gB+GzNEf46eysBXu4se2wogd4ejffhB3+C2X+E3OPg4gbDnoKBD5uzrUREROqgwcLNsmXLzqug2NhYWrdufV7vrW/NLdyUVxhc/dpydqXkMm5ALE9f26VxCyjIgO8mwo7/mc9bDYDRb0JQm8atQ0REmjR1S9WguYUbgJ/3pnHH+6txc7Hw458H0za0kce/GAZs+gR+eBxK882tG0b8C3rfAy4OuRqBiIg4mEZfxE8c26D2IVzaMYyyCoPJP1z4nl91ZrFAzzvg/pXQepC5dcMPj8JHozVlXERE6p3CTTPx5FWdcHWxsGhnKot2nLBPES1iYey3cOUUcPOCg8vgrf6wfqbZuiMiIlIPFG6aiXZhvrbZUk/O2Up2gZ02u3RxgX73wZ9WQExfKMmFbx+CT34H2cfsU5OIiDgVhZtm5JER8bQJ9SE1t5hnvt1u32KC28Lv58Hlz4GrFfYtMltxNn2qVhwREbkgCjfNiKe7Ky/f2B0XC8zeeMx+3VNVXFxhwINw38/QsjcUZ8M3f4JPb9JYHBEROW8KN81Mr1YtGH+JOQ37r3O2klVQYueKgNB4uPtHGP4MuHrA3gXwVj9Y/R+oqLB3dSIi0sQo3DRDfx4RT9tQH07mFvPMtzvsXY7J1Q0GTTRbcWL6QUkezHsMZlwJJ3fbuzoREWlCFG6aodO7p+ZsPMaC7Sn2LumU0A7mWJyrXgYPX0haDW8PgsQpUOYArUwiIuLwFG6aqZ6tWjB+sNk99dhXWzicnm/nik7j4gIXj4cHVkP7K6C8BBInwX+GwNF19q5OREQcnMJNM/bIiHh6tgoku7CUP360noKSMnuXVF1ANNz2OdzwPngHQ+oOeG84zPsLFOfZuzoREXFQCjfNmNXNlbfvuIhQPyu7UnJ57KstONxuHBYLdP0dPLAWut0CGLB6ujngePc8e1cnIiIOSOGmmQv392T67b1wc7Hw/ZZk3vnpgL1LOjufYBjzDtz+NQS0guwk+OwWmHW7Fv8TEZFqFG6E3rFB/LNyt/AX5+/ipz0n7VxRDdoPhwdWwcCHweIKu76DNy+GX96CcgfrVhMREbtQuBEA7ujbipt7x1BhwIOfbWRfqgOPafHwMXcVv285RF9sThv/8a/w7jA4tt7e1YmIiJ0p3AgAFouFZ67rQo8Yc4Dx2A/WkJxdaO+yahbexVz875pXwDMAUrbAu5fB949CUba9qxMRETtRuBEbT3dX3h/bmzYhPhzLKmTsB2scYwXjmri4QO/fw4R10O1mwIC178IbF8O22dqnSkSkGVK4kWqCfa38956LCfe3sudEHvfMXEdhSbm9y/ptvmEw5j9w5zcQ1BbyUuCr38NHoyFtr72rExGRRqRwI2eIbuHNf+/ui7+nG+sPZ/LApxsoLW8iezy1HQZ/WglD/2ruNn4g0dxtfNEzUOJACxWKiEiDUbiRs+oQ4ccH4/rg6e7Ckl2p/N8XmylrKgHH3ROG/uXUCscVpfDzNLOrasdcdVWJiDg5hRs5p96xQbxVuQbO3M3HefjzTU2nBQcgKM5c4fiWz8y1cXKOwhd3wsc3QNo+e1cnIiINROFGanRpx3Deur0X7q7mIn8PfrqRkrImFHAsFuh4ldmKM/gxcPWA/Ythen9Y/C91VYmIOCGFG/lNl3eJ4J07L8LD1YX521O4/5MNFJc1gUHGp/Pwhkv/BvevgnbDzc04l081u6q2z1FXlYiIE1G4kVq5tGM4747tjdXNhUU7T/CnjzdQVNrEAg5AcFu4/Su4+RMIiDG7qr4cB/+9FlJ32rs6ERGpBwo3UmtD4kOrDTK+6/01ZBeW2rusurNYoNM18MAaGPKEOavq4E8wfaC543hhlr0rFBGRC6BwI3UysF0I/727L35WN9YcyuDmd34hNafI3mWdHw9vGPYkTFgDHa8Bo9zccfz1i2D9h1DRBFumRERE4Ubq7uK4ID7/Y39CfK3sSsnlhrdXcjCtCQ/MbRELt3wCd8yGkHgoSINvH4b/DIXDv9i7OhERqSOFGzkvnaP8mf2nAbQO9iYpo5DfTV/J1qNNfD+ndpeZCwBeMRmslXtVzbgSvrobso/auzoREaklhRs5b62CvfnqvgF0jvQnPb+Em//zC4t3nrB3WRfG1R363w8PbYBeYwELbPsaXu8NiVOg1ME3ExUREYUbuTChflZm/bEfA9sFU1BSzvj/rmPmykP2LuvC+YTAta/BH5dBqwFQVgiJkzR1XESkCVC4kQvm7+nOh7+/mJt7x1BhwD/nbudf3+6gvMIJAkBkd/j9D/C7D8A/GrKPmFPHP7gSjq6zd3UiInIWCjdSL9xdXXjhhq48dkUHAD5YcZD7Pl5PfnGZnSurBxYLJNwAE9bCkL+AmxckrYL3LoMvfw+Zh+xdoYiInMZiGM2rfT0nJ4eAgACys7Px9/e3dzlO6dvNx/m/LzdTUlZBxwg/3hvbm+gW3vYuq/7kHIclz8OmTwDD3NKh7x/N7R08A+xdnYiIU6rL32+13Ei9G9U9is/G97NNFb/ujRWsOZhh77Lqj38UjH4T/vgTxA0xt3JY+Tq81gvWzdD6OCIidqZwIw3iotYtmDthIAktzZlUt7+3illrjti7rPoV2Q3u+h/c9gUEtzfXx/luIrwzGA4ss3d1IiLNlrqlpEEVlpTz6Feb+X5LMgB39W/N367ujIebk+Xq8lJY+x4kToaiyvV+2g03N+uM6mnf2kREnEBd/n4r3EiDMwyDN5fu4+UFewDo3boFb93eizB/TztX1gAKMsyAs+4DqKgcTN3pWhj2FIR1tG9tIiJNmMJNDRRu7GfxzhNM/HwTuUVlhPpZmX57L3rHBtm7rIaRcRASX4AtnwMGWFyg+61mS45/lL2rExFpcprsgOKffvqJUaNGERUVhcVi4Ztvvqn2+rhx47BYLNUe/fr1s0+xUmeXdQpn7oRBxIf7cjK3mFv+s4r//nIIp8zXQXEw5h24/xfoNAqMCnN21Wu9YOkkKM6zd4UiIk7LocJNfn4+3bt354033jjnOVdeeSXJycm2xw8//NCIFcqFigvxYc79A7m6WyRlFQb/+N92Jn6+yTnWwzmbsE5w88fwhyUQ089c6XjZFHPn8Q3/hXIn/blFROzIYbulLBYLc+bMYfTo0bZj48aNIysr64wWnbpQt5RjMAyD95Yf5IX5uyivMGgX5sv023vRPtzP3qU1HMOAnXNh4T9OLfzXIhYGToQet4Gb1Y7FiYg4tibbLVUbiYmJhIWFER8fz/jx40lNTa3x/OLiYnJycqo9xP4sFgvjB7fh83v7EeHvyb7UPK59YwWzNzjx7tsWC3S+Dh5YA5c/D97BZsj5biK82h1+eRNK8u1dpYhIk9ekws3IkSP55JNPWLJkCVOnTmXt2rVceumlFBcXn/M9kydPJiAgwPaIiYlpxIrlt/SODeL7hwZxSfsQCkvLeeSLzTzx1RYKS5x4ITw3KwyYABO3wpUvgF8U5CbDj0/Caz3NhQDVXSUict6aVLfUryUnJ9O6dWtmzZrFmDFjznpOcXFxtfCTk5NDTEyMuqUcTHmFwRtL9vHK4j0YBrQP8+X123rSMaIZ/G9UVgybZ8HP0051V4V2hBH/gvaXmy0+IiLNnFN3S50uMjKS1q1bs3fv3nOeY7Va8ff3r/YQx+PqYuHh4e355J6+hPlZ2Zuax3VvrODjVYedczbV6dyscNFYeGAtXDkFvFrAyV3w6U0wcxTsX2qO1xERkVpp0uEmPT2dpKQkIiMj7V2K1JMB7UKY9/AlDO0QSnFZBX/7Zhv3f7KBrIISe5fW8Nw8oN998NAmGPgwuFrh0HL4aDRMH2DOriottHeVIiIOz6HCTV5eHps2bWLTpk0AHDx4kE2bNnHkyBHy8vJ49NFH+eWXXzh06BCJiYmMGjWKkJAQrr/+evsWLvUq2NfKB2P78LerO+HuamHethSufGU5K/el2bu0xuEVaHZJPbgOLv4juPtA6g6Y+yD8uwsse1EDj0VEauBQY24SExMZNmzYGcfHjh3L9OnTGT16NBs3biQrK4vIyEiGDRvGs88+W6dBwpoK3rRsOZrFw7M2cTAtH4sF7r2kDY9cHo/VzdXepTWewizY+BGs/g9kV24+6hdprnbc/VZwaUb3QkSaLW2/UAOFm6anoKSMZ7/byWeVu4p3jvTn1Vt6OPeaOGdTXgY7voHF/4Ksw+ax8K5w+bPQZqgGHouIU1O4qYHCTdO1YHsKT3y9hcyCUjzcXHjs8g7cPSgOV5dm9ke9rBhWvwM/vQzFlTuQR/WEi++FLmPA3Qk3JBWRZk/hpgYKN01bak4Rj3+9hcTdJwG4ODaIl27sRutgHztXZgf56eZWDus/hPLK5Q68gqDXXXDxeAiItmt5IiL1SeGmBgo3TZ9hGHy+Nolnv9tBfkk53h6uPHlVJ27v2wpLc+yayU8zZ1Kt+wCyk8xjbp7mtg4DHwYPb7uWJyJSHxRuaqBw4zySMgp47KvNrDqQAUD/NsG8cEPX5tmKA1BRDnvmw8o34MhK81hADFz+nLntQ3MMfiLiNBRuaqBw41wqKgxm/nKIKfN3UVRagae7C49e3oHfD2yGY3GqGAbs+B8s+NuplpzYS2DoX6D1QIUcEWmSFG5qoHDjnA6n5/OXr7fyy4F0AHq2CuTFG7o1vxlVpyspgBWvwopXoKzIPBbRDfrdDwljtAu5iDQpCjc1ULhxXoZh8NmaJCb9sJO84jLcXS3cN6QtDwxrh6d7M14LJvOwGXA2fQZllSsc+4ZD/wfMoOPqbtfyRERqQ+GmBgo3zi85u5C/zdnG4l2pAMQGe/Pc6K4Mah9i58rsrCDDnFm15l3IPW4eC+0Eo16BVv3sWZmIyG9SuKmBwk3zYBgGP25P4Z9zt3Mix5wmPbpHFE9e3Ykwv2a+Dkx5KWz5HBb+AwrMbjx6jYURz5ibdoqIOCCFmxoo3DQvuUWlTF2wh5m/HMIwwM/qxsQR8Yzt3xo3V4faWq3xFWSYAWfjR+Zzn1AY9Ii5Q7lHM51xJiIOS+GmBgo3zdPmpCz+/r9tbDlqrujbIdyPZ67rQr82wXauzAEcXgnfToS03eZzryBzLM7Ff1BLjog4DIWbGijcNF/lFQZfrEvixfm7yCwoBWBU9yieuLID0S2a+UJ3ZSWw+VP4+RXIPGge8/CDfn+CSx4Bdy+7licionBTA4Ubycwv4eUFu/l0zREMA6xuLoy/pA1/GtoWH6ubvcuzr6rNOZdPg9Tt5rHgdjDqNYgdaNfSRKR5U7ipgcKNVNl2LJvnvt9hW+E41M/KY1d04IZe0c13AcAqVQsBznsC8lLMY73vhuHPgKf+uxGRxqdwUwOFGzmdYRgs2HGCST/s5HB6AQAdI/x44sqODO0Q2jz3qjpdYZY56HjDTPO5XxRc+hR0u1nr44hIo1K4qYHCjZxNcVk5/115mNeX7CWnqAyAvnFB/GVkR3q20qBaDv4E3z4MGQfM5y1iYfBjCjki0mgUbmqgcCM1yS4o5a3EfcxYeYiSsgoAruwSwZ9HxNMhohlv5QBQWmguALjiVShIM48Ftoahf4Xut2jPKhFpUAo3NVC4kdo4nlXItIV7+HrDUQzD/Lt9bfcoJg6PJy6kma8BU5IP6z4wQ07+SfNY7CVwzSsQ0s6upYmI81K4qYHCjdTFnhO5/HvhHuZtMwfVurpYGNOzJRMubUfrYIUcVr8Dy14096xytZpdVQMfBjcPe1cnIk5G4aYGCjdyPrYdy+bfC/fY9qtydbFwXY8oJgxrR5tQXztXZ2eZh+C7R2D/YvN5aEdzVlX8FeqqEpF6o3BTA4UbuRAbjmTy2uK9JO42u2NcLHBNtygmXNqO+PBmPCbHMGDb1+bU8arxOBHdYMgT0PFqhRwRuWAKNzVQuJH6sDkpi9eX7GPRzhO2Y8M7hXHfkLb0jg2yY2V2VpABK16BNe9Bab55LLwrDP2LQo6IXBCFmxoo3Eh92n48mzeX7mPethSq/kvqE9uC+4a0ZViHMFya62KA+emw6k1Y/R8oyTWPxQ2GkS9CWCf71iYiTZLCTQ0UbqQhHDiZx7vLD/D1+mOUlJtTyNuG+nDPoDaM6dUST3dXO1doJwUZ8MsbsPINKC8GiytcPN5sydGmnCJSBwo3NVC4kYZ0IqeID34+yKerj5BbbC4GGOTjwR19W3Fn/1hC/ax2rtBOMg/Bj0/Bru/M597BMOAh6P178Aywa2ki0jQo3NRA4UYaQ25RKV+sO8oHPx/kWFYhAO6uFq7pFsXYAbH0iAm0b4H2sn+pOeg4bbf53MPPDDj9/gT+UfatTUQcmsJNDRRupDGVlVewYMcJ3lt+gA1HsmzHu8cEMm5Aa67qGonVrZl1WZWXwpYvYOVrcHKXeczF3VzleMgTEBhj3/pExCEp3NRA4UbsZcvRLD5ceYjvNifbxuUE+XhwY+9obr+4Na2Cve1cYSOrqIB9C82Vjg+vMI+5ekDve+CS/wPfUPvWJyIOReGmBgo3Ym9pecV8tvoIn645QnJ2ke344PhQbu/biks7huHu6mLHCu3gyGpY8iwcWm4+d/eB/vdD3z+BT7B9axMRh6BwUwOFG3EUZeUVLNmVyserj/DTnpO246F+Vm68KJpb+rRqXq05hgEHEmHxv+D4BvOYqxUSxkCf8RB9kV3LExH7UripgcKNOKLD6fl8uuYIX68/Slpeie34wHbB3NQ7hiu6RDSf6eSGYc6q+ullSN506nhUT7j4j5Bwg/auEmmGFG5qoHAjjqykrILFO0/w2doklu89aVsY0M/TjWu7R3FT7xi6RQdgaQ4r/RoGHFsPa96F7bOhvDL0+beEfvfDRWPB2oy3vBBpZhRuaqBwI01FUkYBX60/ylfrj9qmkwO0D/PlhouiGd2jJREBnnassBHlp8GG/5q7kOeZO7RjDYA+90DvuzXDSqQZULipgcKNNDUVFQa/HEjni3VJzN+WQnGZOdPKYoFB7UIY06slV3SJwNvDzc6VNoKyYtg8y5xGnr6v8qAF4i6BHrdDp1Hg4WPXEkWkYSjc1EDhRpqy7MJSftiazOwNR1l7KNN23NvDlSu6RHBdjygGtQvBzdlnW1VUwO7vzZacqhlWAB6+0OV6c2HAlhqALOJMFG5qoHAjzuJwej5zNh5j9oZjHMkosB0P8fXgmm5RXNsjip4xgc4/PifzMGz5HDZ9Ym7zUCWyh9ll1fV3as0RcQIKNzVQuBFnYxgGG5Oy+GbjMb7bkkxG/qnZVq2CvBnVPZJru7ekQ4STD741DDi8EtZ/CDu+OTUA2epvdld1uR7ihmimlUgTpXBTA4UbcWal5RUs33uSuZuOs2DHCQpKym2vxYf7MqpbFNd0jyIuxMlbMvLTzZacdR9A5sFTxz0DoOM1ZtBpMwxcm8E4JREnoXBTA4UbaS4KSspYvDOV/206zrI9qZSWn/pPPaGlP9d0i+LqrpHEBDnxQoEVFXBkJWz/BnbOhbwTp17zCYWE30G3m8w1dJy9+06kiVO4qYHCjTRH2QWl/Lgjhe+2JLNiXxrlFaf+s+8eHcDV3SK5qmsk0S2cOeiUw5FVsH2O+ShIO/VaSLzZdRV/pTkQ2aWZLJgo0oQo3NRA4Uaau/S8YuZtS+GHrcmsOpDOaTmH7jGBXN01wvmDTnkp7F9qDkTe9T2UnVpHCO9gaH+5GXTaDQerr/3qFBGbJhtufvrpJ1566SXWr19PcnIyc+bMYfTo0bbXDcPgmWee4T//+Q+ZmZn07duXN998ky5dutT6MxRuRE45mVvM/O0pfL/lOKsPZnD6vwbdowO4qqvZouPUXVfFubB7PuyZB/sWQVH2qdfcPM2A02kUxF8BXi3sV6dIM9dkw828efNYsWIFvXr14oYbbjgj3EyZMoXnn3+eDz/8kPj4eJ577jl++ukndu/ejZ9f7WaCKNyInF1qbhE/bkvh+63JrDmYUa1Fp2vLAEZ2jWBkQqRzD0YuL4Wk1bB7nrm/1elTy13cIKYvtBlqDkaO6qkBySKNqMmGm9NZLJZq4cYwDKKiopg4cSJPPPEEAMXFxYSHhzNlyhT++Mc/1uq6Cjciv62qRWfeWbquOkb4cVXXSEYmRNA+3ImnlxsGnNgGO7+FHXPh5M7qr1sDoM1gswur/eXgF2GfOkWaCacMNwcOHKBt27Zs2LCBnj172s677rrrCAwMZObMmWe9TnFxMcXFxbbnOTk5xMTEKNyI1FJ6XjELdpzgh63JrNyfXm0wcttQH67qGsmVCRF0jvR37gUDMw6Y43QOLIWDP1XvvgKI6GZ2XcUNhug+4O5lnzpFnFRdwk2TaVNNSTE3ywsPD692PDw8nMOHD5/zfZMnT+aZZ55p0NpEnFmwr5VbL27FrRe3IjO/hIU7TzB/WwrL955k/8l8Xl+yj9eX7KNVkDcjEyK4MiGCHs64MnJQG/PR5x5z5tXxjeYYnT0/wvENkLLFfPz0Eri4m7OuYgdC64HQqj94OPG4JREH02RablauXMnAgQM5fvw4kZGRtvPGjx9PUlIS8+fPP+t11HIj0jByikpZsjOVeduSSdx90rahJ0BkgCdXdIlgZEIEvWODcHVxsqDza3mpsG8x7FsIh1ac2rm8iqtH9fE6kd01Xkekjpyy5SYiwuzPTklJqRZuUlNTz2jNOZ3VasVqtTZ4fSLNjb+nO6N7tmR0z5YUlJSRuPsk87alsGTnCZKzi/hw5SE+XHmIEF8rl3cJZ2RCBP3aBOPujJt6+oZBj1vNh2GYXViHV8LhFWYXVs4xc4PPQ8thybPg7m227ET3gZiLIfpi8Am2908h4jSaTLiJi4sjIiKChQsX2sbclJSUsGzZMqZMmWLn6kSaN28PN9u08aLScpbvTWPetmQW7ThBWl4xn64+wqerjxDo7c7wTuFc2SWCQe1D8HR3wsXyLBYIbms+et1php30/eZYnQOJZsApyj4VdqqEdqrsxhoArQeB37n/T5uI1MyhuqXy8vLYt28fAD179mTatGkMGzaMoKAgWrVqxZQpU5g8eTIzZsygffv2TJo0icTERE0FF3FQJWUV/HIgnfnbUliwPYX00zb19LW6MaxjGCMTIhgSH4qPtcn8f60LU1EBaXvg6Bpz2nnSWkjbfeZ5Aa2gZU+I6gUte5m7nHvq3yxpvprsbKnExESGDRt2xvGxY8fy4Ycf2hbxe+edd6ot4peQkFDrz1C4EbGP8gqDtYcymL8thfnbUkjJKbK9ZnVzYUh8KFcmRHBZp3ACvNztWKkd5Ked6sY6tMKcgs6v/2m2QHgXc+xOq35md1Zga+2JJc1Gkw03jUHhRsT+KioMNh/NYv62FOZtS+FIRoHtNTcXCwPahXBllwhGdA4n1K8Zjpkryobjm8xZWMc2mDOzspPOPM8rCCK7mdPQI7ubj6C24OKE45qk2VO4qYHCjYhjMQyDncm5zN+ewvxtyew5kWd7zWKBPrFBXNklgisSImgZ2IzXjslJruzGquzOSt4MFaVnnucZYHZlRfeGlr3NwOMXoRYeafIUbmqgcCPi2PafzOPH7WbX1Zaj1RfK69oygCsTIriiSzjtwpx4deTaKC2C1B3m2jrJlWvspGyFsqIzz/UKMru0whMgoitE9YCQDpqOLk2Kwk0NFG5Emo5jWYX8uC2F+dtTWHuo+saebUN9uKJLBFd0iaBbdIDzLRp4PspL4cR2OLYOjq6HY+shfS8YFWee6+ZVGXR6msEnrDOEdtCgZXFYCjc1ULgRaZpO5hazaOcJftyewop9aZSWn/qnK8Lfk8u7hHN55wj6tglyzrV0zldpIZzcZYaelG1m607yZijJPfv5/tEQ3rlyHE/leJ4WserWErtTuKmBwo1I05dTVMrSXaks2H6CxN2p5JeU217z93Tj0o5hjOgcwZAOofg2lynmdVFRARn7zYHKxzeZ3Vsnd0Fu8tnPtwZAWEcIiYfQjmYLT2gHCIhR6JFGo3BTA4UbEedSVFrOL/vT+XF7Cot2niAt79RaOh6uLgxoF8zwTuEM7xRORICnHSttAgozIXWXORU9ZYvZwpO6E8pLzn6+NaByLE8XiEgwg09we622LA1C4aYGCjcizqu8wmDjkUwW7jjBgh0nOJiWX+31ri0DuKxTGMM7hdMlysl3Ma8vZSXmooMnd1V+3W1+Tdt79tlaAF4tzJATGm+O5QnrBGFdzG0qdM/lPCnc1EDhRqR5MAyD/SfzWLDjBIt2nGBjUla1AckR/p5c2imMyzqGMaBtCF4eTrgVREMqKzEHK6dsgxNbzTE9aXvPvh5PFe9gM/QEt4PgNuaaPCGVz92a4XpGUicKNzVQuBFpnk7mFrN0VyoLd57g571pFJaeGqdjdXNhQNtghnUMY1iHMGKCvO1YaRNXUmCO50nba7bypO4wHxkHzj5rC8DiCkFxZrdWWCcz7AS1gRZx4BOi1h4BFG5qpHAjIkWl5aw6kM7inaks2ZXKsazCaq+3DfVhWIcwhnQIpU9skHNu8NnYSgvNsJO+z9xINGO/+TVtLxRnn/t9Hn5m8AmJPzWQOaSDeUytPc2Kwk0NFG5E5HSGYbD7RC6Ju0+yZFcq6w9nUl5x6p9FT3cX+rcJZkh8KIPjQ4kL8dFYnfpkGJCbAid3Vrb07DRbeTIOQs4xztxjq4oF/KPMaeotYs1WnpB2ld1ebcG9Ga9m7aQUbmqgcCMiNckuLGX53pMs232Sn/ae5EROcbXXWwZ6cUn7EAa1D2Fg2xBa+HjYqdJmoLQIsg6brT1VA5mrvpbk1fBGCwTGmF1bga3MDUYDW5shKLgteAc11k8g9UjhpgYKNyJSW1WtOst2n2TZnpOsO5RJSfmpcSMWC3SO9GdguxAGtguhT2wLvD20rk6DMwwoSIfMQ5WPg5B+wBzgnLbH3Hi0Jl4tKsf1tDUDT2ArMwwFxEBANLg2s13pmwiFmxoo3IjI+SooKWPNwQyW701j+d6T1Tb5BHB3tdAjJpD+bYLp1yaYXq1baLxOYzMMyE8zg07mIcg6ApmHK79WdXXVwOJihpzgtmbLT1BbaNHaDD0BMWYwUrekXSjc1EDhRkTqS2pOESv3p7NiXxor96efMTDZw9WFHjGBXBwXxMVxQfRq3UIrJttbSYE5pid9n/nIOgxZSeYU9qwkKC+u+f1uXmYrT9U4n6A482tgKwhoae7KLg1C4aYGCjci0hAMw+BwegGrDqSz6kA6vxxIP2O8jquLhYQof3rHBtG7dQsuim1BmJ9WTXYYFRWQd6JyQHPVY39l+DkK+am/fQ0PPzPkBERXjvNpfWrQs1p+LojCTQ0UbkSkMRiGwcG0fNYczGDNoQzWHMzgaGbhGee1CvKmd+sW9GwVSM9WLegY4YebNv50TGXFZrdW1hFzNlfmwVNfs4+a21f8FjdP8IsE/5bmbK/AVmYAqhr47N8S3DRI/WwUbmqgcCMi9nIsq5C1BzNYdziDdYcy2X0il1//C+zl7kq36AB6tAqkR3Qg3WMCiQzw1PTzpqAkH3KOm0En+6jZ5WUb9HwI8k/W7jreIZUBKNL8GhBjdoUFtjK/94sE1+bXvalwUwOFGxFxFDlFpWw8ksWGw5lsOJLJpqQscovKzjgv1M9K9+gAEloG0K3yq7qzmqDSInPn9dzkyhCUZLYCnT7o+bfG/ABgAZ9Q8Is49aia6VX18IsCd+f6HVG4qYHCjYg4qooKcz+sDUcy2Xw0m81JWexKya22qGCVcH8rCVEBdInyp3NUAAkt/WkZ6KUWnqbMMKAgA3KPmwsbVoWgrCTIrgxB2cfOvWHpr3kGgG8E+IWbX/2jzODj39IcF+QXZa7549I0ZvQp3NRA4UZEmpLCknJ2JGez5Wg2W49ms/VYNvtO5p3RnQUQ4OVOxwg/OkX60ynS/No+zE+bgjqTinJzjZ/cFPORl3JaV1jSqS6xsqLaXc/iau7f5RsGvuGnxgMFVI4J8o0wX/MOtnsIUripgcKNiDR1+cVl7EjOYfuxbLYfz2H78Rz2puZSWn7mP+cWC8QG+9Ah3I/4CD86RvjRPsyX2BAf3DVw2TkZhjm4OS/VnP2Vd+K0rrCj5qDo7GOVY4BqGwEsZsDxDTttPFDUqXFBPqHm6z6h4OHTIDPCFG5qoHAjIs6ouKycfal57EzOZVdyDjtTctiZnEtGfslZz3dzsRAX4kN8uB9tw3xpF+ZL21Af2ob6auHB5qK8DArSKgNQ6mldYZXhJ+eY+VpBBrUPQZhrAQ2YAJf+rV7Lrcvf7+Y33FpExAlZ3VzpEhVAl6hTi8gZhkFaXgm7U3LZfSKX3Sk57DmRx77UPPKKy9ibmsfe1OqrLFssEN3CizYhvrQJ9aFNiA9tQs3vw/08cXHRmB6n4ep2akByTcrLzK6w/JOntQIlm2ODco6bwSg/zVwHqKwIygrB1b7T2dVyIyLSzBiGwfHsIvaeyGVvZdjZd9L8ml147sGqnu4uxAb7EBfiQ2yID7HB3rQO9iE22IcwP6uCT3NnGOZ0+II0cPcB39B6vby6pWqgcCMicnaGYZCeX8L+1DwOpOVz4GQeB07mcyAtn6SMAsrOMmuriqe7CzEtvGkd7E2rIB9aBXnROtiHmCAvolt4q6tLLpi6pUREpM4sFgshvlZCfK30bRNc7bXS8gqOZhZyKM0MO4fS8jmcUcDh9HyOZhZSVFpx1m6uKmF+VloFeRMT5E10Cy9iWphfo1t4ExnoqcHNUq/UciMiIhektLyCY5mFHM4o4EhGAUfS8zmSUcDh9AKOZhaSV3zmwoSns1ggwt+TloFetGzhZfsaFehFdKD51UcbjjZ7arkREZFG4+7qYo7BCfE54zXDMMgsKCWpMvgczSzkaKb5Nanya0lZBcnZRSRnF7Hu8Nn3Zwr0dicywIuWgZ5EBXoRGeBFVKAnkQFeRAZ4EhGg1h85ReFGREQajMViIcjHgyAfD7rHBJ7xetWMrqOZBRzLKuRoZiHHswo5llnIsSzzkVtURlZBKVkFpexMzjnH50Cor9UWdE4PPVXfh/lbsbpp7E9zoG4pERFxaDlFpSRnFXE8q5Dj2Wb4Sc4q4lhWIcnZRaRkF1FSXlGrawX7eBAR4EmEv6fta/hpz8P9PfH3dNM2Fg5I3VIiIuI0/D3d8Y9wp0OE31lfr6gwZ3mlZBdxPLuw2teU7CJScswur5KyCtLzS0jPL2H78bO3AIG5M7sZdKyE+1cGINvDPKZWIMemcCMiIk2ai4uFUD8roX5WukYHnPUcwzDIyC8hJaeIE5Vh5/TwcyLH/D6nqIzC0nIOpuVzMC2/xs9t4e1+ltDjSbif1fzqb84801igxqdwIyIiTs9isRDsayXY11ptFedfKywpN4NOZeAxH8Wk5BSRetr3JWUVZBaUkllQyq6U3Bo+1+wKC/Uzw06YX2UIqgxAVc9D/RSC6pPCjYiISCUvD9dzzvyqYhgG2YWlnMgptgWhk7nF1cLQicpjZRXmgOm0vBJ2Jtf82WYIOhV6bI9fhSAtiPjbFG5ERETqwGKxEOjtQaC3xznHAYE5FiijoITUyrCTmltkfm/7WszJnCJO5hVTWm7YxgPV1BIE4O/pZoYgP3PsT1jl96G2MGQl1K95D4xWuBEREWkALi6nVnzuHHXu2T0VFQZZhaWVAaiY1F9/zS22BaPisgpyisrIKSpj/8maxwRZ3VxOBZ7Twk9oZQCqOhbs44Gbk3WJKdyIiIjYkYvLqbWAOkWe+zzDMMgpLONknhl0Tg89J/OKK4+ZgSi3qIzisorKRRMLa/z8qnFBIb5mF1ior9U2QDvUz0qob1VrkBU/a9NoDVK4ERERaQIsFgsB3u4EeLvTLuzc3WEARaXlnKwMPyerWn9yim3HUnPN79PyiqkwsI0L+q0usarWoKrQU/V9iK/1jOP2HBukcCMiIuJkPN1diancqLQm5RXmFPmq0JOWV1ItEKXlmq1CJ+vYGjRuQCxPX9ulPn+kOlG4ERERaaZcT1sjqDM1r/pbWGK2BlWFnaqvaVXPc08dD/WzNtJPcHZNKtw8/fTTPPPMM9WOhYeHk5KSYqeKREREmgcvD1daBXvTKrjm1iDDMCivsO/OTk0q3AB06dKFRYsW2Z67umq+v4iIiKOwWCy4udp30HGTCzdubm5ERETU+vzi4mKKi4ttz3Nyzr2fiIiIiDR9TW5i+969e4mKiiIuLo5bbrmFAwcO1Hj+5MmTCQgIsD1iYmIaqVIRERGxB4thGPbtGKuDefPmUVBQQHx8PCdOnOC5555j165dbN++neDg4LO+52wtNzExMbXaMl1EREQcQ05ODgEBAbX6+92kws2v5efn07ZtWx5//HEeeeSRWr2nLjdHREREHENd/n43uW6p0/n4+NC1a1f27t1r71JERETEQTTpcFNcXMzOnTuJjKxhvWoRERFpVppUuHn00UdZtmwZBw8eZPXq1fzud78jJyeHsWPH2rs0ERERcRBNair40aNHufXWW0lLSyM0NJR+/fqxatUqWrdube/SRERExEE0qXAza9Yse5cgIiIiDq5JdUuJiIiI/BaFGxEREXEqCjciIiLiVBRuRERExKk0qQHF9aFqQWZtoCkiItJ0VP3drs3GCs0u3OTm5gJoA00REZEmKDc3l4CAgBrPadJ7S52PiooKjh8/jp+fHxaLpV6vXbUpZ1JSkvatakC6z41D97lx6D43Dt3nxtGQ99kwDHJzc4mKisLFpeZRNc2u5cbFxYXo6OgG/Qx/f3/9x9MIdJ8bh+5z49B9bhy6z42joe7zb7XYVNGAYhEREXEqCjciIiLiVBRu6pHVauWf//wnVqvV3qU4Nd3nxqH73Dh0nxuH7nPjcJT73OwGFIuIiIhzU8uNiIiIOBWFGxEREXEqCjciIiLiVBRuRERExKko3NSTt956i7i4ODw9PbnoootYvny5vUtq0iZPnkyfPn3w8/MjLCyM0aNHs3v37mrnGIbB008/TVRUFF5eXgwdOpTt27fbqWLnMHnyZCwWCxMnTrQd032uH8eOHeOOO+4gODgYb29vevTowfr1622v6z5fuLKyMv72t78RFxeHl5cXbdq04V//+hcVFRW2c3Sfz89PP/3EqFGjiIqKwmKx8M0331R7vTb3tbi4mAcffJCQkBB8fHy49tprOXr0aMMUbMgFmzVrluHu7m68++67xo4dO4yHH37Y8PHxMQ4fPmzv0pqsK664wpgxY4axbds2Y9OmTcbVV19ttGrVysjLy7Od88ILLxh+fn7G119/bWzdutW4+eabjcjISCMnJ8eOlTdda9asMWJjY41u3boZDz/8sO247vOFy8jIMFq3bm2MGzfOWL16tXHw4EFj0aJFxr59+2zn6D5fuOeee84IDg42vvvuO+PgwYPGl19+afj6+hqvvPKK7Rzd5/Pzww8/GE899ZTx9ddfG4AxZ86caq/X5r7ed999RsuWLY2FCxcaGzZsMIYNG2Z0797dKCsrq/d6FW7qwcUXX2zcd9991Y517NjR+Mtf/mKnipxPamqqARjLli0zDMMwKioqjIiICOOFF16wnVNUVGQEBAQYb7/9tr3KbLJyc3ON9u3bGwsXLjSGDBliCze6z/XjiSeeMAYNGnTO13Wf68fVV19t3H333dWOjRkzxrjjjjsMw9B9ri+/Dje1ua9ZWVmGu7u7MWvWLNs5x44dM1xcXIz58+fXe43qlrpAJSUlrF+/nssvv7za8csvv5yVK1faqSrnk52dDUBQUBAABw8eJCUlpdp9t1qtDBkyRPf9PDzwwANcffXVDB8+vNpx3ef6MXfuXHr37s2NN95IWFgYPXv25N1337W9rvtcPwYNGsTixYvZs2cPAJs3b+bnn3/mqquuAnSfG0pt7uv69espLS2tdk5UVBQJCQkNcu+b3caZ9S0tLY3y8nLCw8OrHQ8PDyclJcVOVTkXwzB45JFHGDRoEAkJCQC2e3u2+3748OFGr7EpmzVrFhs2bGDt2rVnvKb7XD8OHDjA9OnTeeSRR3jyySdZs2YNDz30EFarlbvuukv3uZ488cQTZGdn07FjR1xdXSkvL+f555/n1ltvBfT73FBqc19TUlLw8PCgRYsWZ5zTEH8rFW7qicViqfbcMIwzjsn5mTBhAlu2bOHnn38+4zXd9wuTlJTEww8/zIIFC/D09DznebrPF6aiooLevXszadIkAHr27Mn27duZPn06d911l+083ecL8/nnn/Pxxx/z6aef0qVLFzZt2sTEiROJiopi7NixtvN0nxvG+dzXhrr36pa6QCEhIbi6up6RPFNTU89IsVJ3Dz74IHPnzmXp0qVER0fbjkdERADovl+g9evXk5qaykUXXYSbmxtubm4sW7aM1157DTc3N9u91H2+MJGRkXTu3LnasU6dOnHkyBFAv8/15bHHHuMvf/kLt9xyC127duXOO+/kz3/+M5MnTwZ0nxtKbe5rREQEJSUlZGZmnvOc+qRwc4E8PDy46KKLWLhwYbXjCxcuZMCAAXaqqukzDIMJEyYwe/ZslixZQlxcXLXX4+LiiIiIqHbfS0pKWLZsme57HVx22WVs3bqVTZs22R69e/fm9ttvZ9OmTbRp00b3uR4MHDjwjKUM9uzZQ+vWrQH9PteXgoICXFyq/1lzdXW1TQXXfW4YtbmvF110Ee7u7tXOSU5OZtu2bQ1z7+t9iHIzVDUV/P333zd27NhhTJw40fDx8TEOHTpk79KarD/96U9GQECAkZiYaCQnJ9seBQUFtnNeeOEFIyAgwJg9e7axdetW49Zbb9WUznpw+mwpw9B9rg9r1qwx3NzcjOeff97Yu3ev8cknnxje3t7Gxx9/bDtH9/nCjR071mjZsqVtKvjs2bONkJAQ4/HHH7edo/t8fnJzc42NGzcaGzduNABj2rRpxsaNG21LntTmvt53331GdHS0sWjRImPDhg3GpZdeqqngju7NN980WrdubXh4eBi9evWyTVmW8wOc9TFjxgzbORUVFcY///lPIyIiwrBarcbgwYONrVu32q9oJ/HrcKP7XD++/fZbIyEhwbBarUbHjh2N//znP9Ve132+cDk5OcbDDz9stGrVyvD09DTatGljPPXUU0ZxcbHtHN3n87N06dKz/ps8duxYwzBqd18LCwuNCRMmGEFBQYaXl5dxzTXXGEeOHGmQei2GYRj13x4kIiIiYh8acyMiIiJOReFGREREnIrCjYiIiDgVhRsRERFxKgo3IiIi4lQUbkRERMSpKNyIiIiIU1G4EREREaeicCMiTi82NpZXXnnF3mWISCNRuBGRejVu3DhGjx4NwNChQ5k4cWKjffaHH35IYGDgGcfXrl3Lvffe22h1iIh9udm7ABGR31JSUoKHh8d5vz80NLQeqxERR6eWGxFpEOPGjWPZsmW8+uqrWCwWLBYLhw4dAmDHjh1cddVV+Pr6Eh4ezp133klaWprtvUOHDmXChAk88sgjhISEMGLECACmTZtG165d8fHxISYmhvvvv5+8vDwAEhMT+f3vf092drbt855++mngzG6pI0eOcN111+Hr64u/vz833XQTJ06csL3+9NNP06NHDz766CNiY2MJCAjglltuITc313bOV199RdeuXfHy8iI4OJjhw4eTn5/fQHdTROpC4UZEGsSrr75K//79GT9+PMnJySQnJxMTE0NycjJDhgyhR48erFu3jvnz53PixAluuummau+fOXMmbm5urFixgnfeeQcAFxcXXnvtNbZt28bMmTNZsmQJjz/+OAADBgzglVdewd/f3/Z5jz766Bl1GYbB6NGjycjIYNmyZSxcuJD9+/dz8803Vztv//79fPPNN3z33Xd89913LFu2jBdeeAGA5ORkbr31Vu6++2527txJYmIiY8aMQfsQizgGdUuJSIMICAjAw8MDb29vIiIibMenT59Or169mDRpku3YBx98QExMDHv27CE+Ph6Adu3a8eKLL1a75unjd+Li4nj22Wf505/+xFtvvYWHhwcBAQFYLJZqn/drixYtYsuWLRw8eJCYmBgAPvroI7p06cLatWvp06cPABUVFXz44Yf4+fkBcOedd7J48WKef/55kpOTKSsrY8yYMbRu3RqArl27XsDdEpH6pJYbEWlU69evZ+nSpfj6+toeHTt2BMzWkiq9e/c+471Lly5lxIgRtGzZEj8/P+666y7S09Pr1B20c+dOYmJibMEGoHPnzgQGBrJz507bsdjYWFuwAYiMjCQ1NRWA7t27c9lll9G1a1duvPFG3n33XTIzM2t/E0SkQSnciEijqqioYNSoUWzatKnaY+/evQwePNh2no+PT7X3HT58mKuuuoqEhAS+/vpr1q9fz5tvvglAaWlprT/fMAwsFstvHnd3d6/2usVioaKiAgBXV1cWLlzIvHnz6Ny5M6+//jodOnTg4MGDta5DRBqOwo2INBgPDw/Ky8urHevVqxfbt28nNjaWdu3aVXv8OtCcbt26dZSVlTF16lT69etHfHw8x48f/83P+7XOnTtz5MgRkpKSbMd27NhBdnY2nTp1qvXPZrFYGDhwIM888wwbN27Ew8ODOXPm1Pr9ItJwFG5EpMHExsayevVqDh06RFpaGhUVFTzwwANkZGRw6623smbNGg4cOMCCBQu4++67awwmbdu2paysjNdff50DBw7w0Ucf8fbbb5/xeXl5eSxevJi0tDQKCgrOuM7w4cPp1q0bt99+Oxs2bGDNmjXcddddDBky5KxdYWezevVqJk2axLp16zhy5AizZ8/m5MmTdQpHItJwFG5EpME8+uijuLq60rlzZ0JDQzly5AhRUVGsWLGC8vJyrrjiChISEnj44YcJCAjAxeXc/yT16NGDadOmMWXKFBISEvjkk0+YPHlytXMGDBjAfffdx80330xoaOgZA5LBbHH55ptvaNGiBYMHD2b48OG0adOGzz//vNY/l7+/Pz/99BNXXXUV8fHx/O1vf2Pq1KmMHDmy9jdHRBqMxdDcRREREXEiarkRERERp6JwIyIiIk5F4UZEREScisKNiIiIOBWFGxEREXEqCjciIiLiVBRuRERExKko3IiIiIhTUbgRERERp6JwIyIiIk5F4UZEREScyv8DgGzUgTVUL8UAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "plt.plot(range(iters+1), off_diagonal_norm_diff, label=r'Off-diagonal norm')\n", + "plt.plot(range(iters+1), off_diagonal_norm_diff_least_squares, label=r'Least squares')\n", + "plt.xlabel('Iterations')\n", + "plt.ylabel(r'$||\\sigma(H_k)||$')\n", + "plt.legend()\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Energy fluctuation\n", + "\n", + "This cost function is defined as: $\\Xi_k^2 (\\mu) = \\langle \\mu | H_k^2| \\mu \\rangle - \\langle \\mu | H_k| \\mu \\rangle^2$" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.5|INFO|2024-03-15 18:17:12]: Using qibojit (numba) backend on /CPU:0\n" + ] + } + ], + "source": [ + "# Hamiltonian\n", + "set_backend(\"qibojit\", \"numba\")\n", + "\n", + "# hamiltonian parameters\n", + "nqubits = 3\n", + "h = 3.0\n", + "\n", + "# define the hamiltonian\n", + "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=h)\n", + "\n", + "# define the energy fluctuation cost function\n", + "cost = DoubleBracketCostFunction.energy_fluctuation\n", + "# define the state\n", + "state = 0\n", + "# initialize class\n", + "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost, state=state)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "grid_search step: 0.8585872727272726\n", + "hyperopt_search step: 0.3413442272248831\n", + "polynomial_approximation step: 0.028303853122485182\n" + ] + } + ], + "source": [ + "# generate data for plotting sigma decrease of the first step\n", + "d = np.diag(np.linspace(1,2**nqubits,2**nqubits))\n", + "s_space = np.linspace(1e-5, 0.9, 1000)\n", + "off_diagonal_norm_diff = []\n", + "fluctuation = []\n", + "for s in s_space:\n", + " dbi_eval = deepcopy(dbi)\n", + " dbi_eval(s,d=d)\n", + " off_diagonal_norm_diff.append(dbi_eval.off_diagonal_norm - dbi.off_diagonal_norm)\n", + " fluctuation.append(dbi_eval.energy_fluctuation(state=state))\n", + "\n", + "# grid_search\n", + "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.grid_search,d=d)\n", + "print('grid_search step:', step_grid)\n", + "# hyperopt\n", + "step_hyperopt = dbi.choose_step(scheduling=DoubleBracketScheduling.hyperopt,d=d, max_evals=100, step_max=0.6)\n", + "print('hyperopt_search step:', step_hyperopt)\n", + "# polynomial\n", + "step_poly = dbi.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation,d=d, n=3)\n", + "print('polynomial_approximation step:', step_poly)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The minimum for cost function in the tested range is: 0.8585872727272726\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the results\n", + "plt.figure()\n", + "plt.plot(s_space, fluctuation)\n", + "plt.xlabel('s')\n", + "plt.axvline(x=step_grid, color='r', linestyle='-',label='grid_search')\n", + "plt.axvline(x=step_hyperopt, color='g', linestyle='--',label ='hyperopt')\n", + "plt.axvline(x=step_poly, color='m', linestyle='-.',label='polynomial')\n", + "plt.title('First DBI step')\n", + "plt.ylabel('Energy fluctuation')\n", + "plt.legend()\n", + "plt.figure()\n", + "plt.plot(s_space, off_diagonal_norm_diff)\n", + "plt.axvline(x=step_grid, color='r', linestyle='-',label='grid_search')\n", + "plt.axvline(x=step_hyperopt, color='g', linestyle='--',label='hyperopt')\n", + "plt.axvline(x=step_poly, color='m', linestyle='-.',label='polynomial')\n", + "plt.ylabel(r'$||\\sigma(H_0)||-\\sigma(H_k)||$')\n", + "plt.xlabel('s')\n", + "plt.title('First DBI step')\n", + "plt.legend()\n", + "print('The minimum for cost function in the tested range is:', step_grid)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "d = np.diag(np.linspace(1,2**nqubits,2**nqubits))\n", + "off_diagonal_norm_diff = [dbi.off_diagonal_norm]\n", + "energy_fluc = [dbi.energy_fluctuation(state=state)]\n", + "iters = 50\n", + "dbi_ = deepcopy(dbi)\n", + "for _ in range(iters):\n", + " step_poly = dbi_.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation, d=d, n=3)\n", + " dbi_(step_poly,d=d)\n", + " off_diagonal_norm_diff.append(dbi_.off_diagonal_norm)\n", + " energy_fluc.append(dbi_.energy_fluctuation(state=state))" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Energy fluctuation')" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "plt.plot(range(iters+1), off_diagonal_norm_diff)\n", + "plt.xlabel('Iterations')\n", + "plt.ylabel(r'$||\\sigma(H_k)||$')\n", + "\n", + "plt.figure()\n", + "plt.plot(range(iters+1), energy_fluc)\n", + "plt.xlabel('Iterations')\n", + "plt.ylabel(r'Energy fluctuation')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "iters = 10\n", + "columnNorm = np.empty((2**nqubits,iters))\n", + "d = (np.diag(np.linspace(1,2**nqubits,2**nqubits)))\n", + "for i in range(2**nqubits):\n", + " dbi_ = deepcopy(dbi)\n", + " dbi_.state = i\n", + " for j in range(iters):\n", + " step_poly = dbi_.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation, d=d, n=3)\n", + " dbi_(step_poly,d=d)\n", + " columnNorm[i,j] = np.linalg.norm(dbi_.h.matrix[:,i])\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0, 'Iterations')" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "eigvals = np.linalg.eigh(dbi_.h.matrix)[0]\n", + "plt.figure()\n", + "for i in range(2**nqubits):\n", + " plt.plot(range(iters), columnNorm[i], label='State ' + str(i))\n", + " plt.axhline(y=eigvals[i], color='r', linestyle='--')\n", + "plt.xlabel('Iterations')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[20], line 8\u001b[0m\n\u001b[0;32m 5\u001b[0m step \u001b[39m=\u001b[39m \u001b[39m1e-2\u001b[39m\n\u001b[0;32m 6\u001b[0m iterations \u001b[39m=\u001b[39m \u001b[39m100\u001b[39m\n\u001b[1;32m----> 8\u001b[0m d, loss, grad, diags \u001b[39m=\u001b[39m gradient_ascent(dbi, d,step, iterations)\n\u001b[0;32m 10\u001b[0m n \u001b[39m=\u001b[39m \u001b[39m3\u001b[39m\n", + "File \u001b[1;32m~\\Documents\\GitHub\\qibo\\src\\qibo\\models\\dbi\\utils_scheduling.py:253\u001b[0m, in \u001b[0;36mgradient_ascent\u001b[1;34m(dbi_object, d, step, iterations)\u001b[0m\n\u001b[0;32m 250\u001b[0m diagonals[:,\u001b[39m0\u001b[39m] \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mdiag(d)\n\u001b[0;32m 252\u001b[0m \u001b[39mfor\u001b[39;00m i \u001b[39min\u001b[39;00m \u001b[39mrange\u001b[39m(iterations):\n\u001b[1;32m--> 253\u001b[0m grad[i,:] \u001b[39m=\u001b[39m gradientDiagonal(dbi_object, d, H)\n\u001b[0;32m 254\u001b[0m \u001b[39mfor\u001b[39;00m j \u001b[39min\u001b[39;00m \u001b[39mrange\u001b[39m(\u001b[39mlen\u001b[39m(d)):\n\u001b[0;32m 255\u001b[0m d[j,j] \u001b[39m=\u001b[39m d[j,j] \u001b[39m+\u001b[39m step\u001b[39m*\u001b[39mgrad[i,j] \u001b[39m# note the plus sign as we maximize the potential\u001b[39;00m\n", + "File \u001b[1;32m~\\Documents\\GitHub\\qibo\\src\\qibo\\models\\dbi\\utils_scheduling.py:237\u001b[0m, in \u001b[0;36mgradientDiagonal\u001b[1;34m(dbi_object, d, H)\u001b[0m\n\u001b[0;32m 235\u001b[0m grad \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mzeros(\u001b[39mlen\u001b[39m(d))\n\u001b[0;32m 236\u001b[0m \u001b[39mfor\u001b[39;00m i \u001b[39min\u001b[39;00m \u001b[39mrange\u001b[39m(\u001b[39mlen\u001b[39m(d)):\n\u001b[1;32m--> 237\u001b[0m derivative \u001b[39m=\u001b[39m dpolynomial_diDiagonal(dbi_object,d,H,i)\n\u001b[0;32m 238\u001b[0m grad[i] \u001b[39m=\u001b[39m derivative\u001b[39m-\u001b[39md[i,i]\n\u001b[0;32m 239\u001b[0m \u001b[39mreturn\u001b[39;00m grad\n", + "File \u001b[1;32m~\\Documents\\GitHub\\qibo\\src\\qibo\\models\\dbi\\utils_scheduling.py:224\u001b[0m, in \u001b[0;36mdpolynomial_diDiagonal\u001b[1;34m(dbi_object, d, H, i)\u001b[0m\n\u001b[0;32m 220\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mdpolynomial_diDiagonal\u001b[39m(dbi_object, d,H,i):\n\u001b[0;32m 221\u001b[0m \u001b[39m# Derivative of polynomial approximation of potential function with respect to diagonal elements of d (full-diagonal ansatz)\u001b[39;00m\n\u001b[0;32m 222\u001b[0m \u001b[39m# Formula can be expanded easily to any order, with n=3 corresponding to cubic approximation\u001b[39;00m\n\u001b[0;32m 223\u001b[0m derivative \u001b[39m=\u001b[39m \u001b[39m0\u001b[39m\n\u001b[1;32m--> 224\u001b[0m s \u001b[39m=\u001b[39m polynomial_step(dbi_object, d, H, i)\n\u001b[0;32m 225\u001b[0m A \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mzeros(d\u001b[39m.\u001b[39mshape)\n\u001b[0;32m 226\u001b[0m Gamma_list \u001b[39m=\u001b[39m dbi_object\u001b[39m.\u001b[39mgenerate_Gamma_list(\u001b[39m4\u001b[39m, d)\n", + "File \u001b[1;32m~\\Documents\\GitHub\\qibo\\src\\qibo\\models\\dbi\\utils_scheduling.py:127\u001b[0m, in \u001b[0;36mpolynomial_step\u001b[1;34m(dbi_object, n, n_max, d, coef, cost)\u001b[0m\n\u001b[0;32m 124\u001b[0m \u001b[39mif\u001b[39;00m d \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m 125\u001b[0m d \u001b[39m=\u001b[39m dbi_object\u001b[39m.\u001b[39mdiagonal_h_matrix\n\u001b[1;32m--> 127\u001b[0m \u001b[39mif\u001b[39;00m n \u001b[39m>\u001b[39;49m n_max:\n\u001b[0;32m 128\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\n\u001b[0;32m 129\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mNo solution can be found with polynomial approximation. Increase `n_max` or use other scheduling methods.\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[0;32m 130\u001b[0m )\n\u001b[0;32m 131\u001b[0m \u001b[39mif\u001b[39;00m coef \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n", + "\u001b[1;31mValueError\u001b[0m: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()" + ] + } + ], + "source": [ + "cost = DoubleBracketCostFunction.least_squares\n", + "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)\n", + "d = np.diag(np.linspace(1,2**nqubits,2**nqubits))\n", + "\n", + "step = 1e-2\n", + "iterations = 100\n", + "\n", + "d, loss, grad, diags = gradient_ascent(dbi, d,step, iterations)\n", + "\n", + "n = 3" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "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.9.18" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "c4f92193806e2908606a5f23edd55a5282f2f433b73b1c504507f9256ed9f0b4" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index 0446ffbb9a..2069296058 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -82,7 +82,6 @@ def __init__( self.mode = mode self.scheduling = scheduling self.cost = cost - self.cost_str = cost.name self.state = state def __call__( @@ -100,7 +99,7 @@ def __call__( if d is None: d = self.diagonal_h_matrix operator = self.backend.calculate_matrix_exp( - 1.0j * step, + 1.0j*step, self.commutator(d, self.h.matrix), ) elif mode is DoubleBracketGeneratorType.group_commutator: @@ -115,6 +114,7 @@ def __call__( operator_dagger = self.backend.cast( np.matrix(self.backend.to_numpy(operator)).getH() ) + self.h.matrix = operator @ self.h.matrix @ operator_dagger @staticmethod @@ -140,20 +140,17 @@ def off_diagonal_norm(self): return np.sqrt( np.real(np.trace(self.backend.to_numpy(off_diag_h_dag @ self.off_diag_h))) ) - @property - def least_squares(self,d: np.array): - """Least squares cost function.""" - H = self.backend.cast( - np.matrix(self.backend.to_numpy(self.h)).getH() - ) - D = d - return -(np.linalg.trace(H@D)-0.5(np.linalg.norm(H)**2+np.linalg.norm(D)**2)) @property def backend(self): """Get Hamiltonian's backend.""" return self.h0.backend + def least_squares(self, D: np.array): + """Least squares cost function.""" + H = self.h.matrix + return -np.real(np.trace(H@D)-0.5*(np.linalg.norm(H)**2+np.linalg.norm(D)**2)) + def choose_step( self, d: Optional[np.array] = None, @@ -192,7 +189,7 @@ def loss(self, step: float, d: np.array = None, look_ahead: int = 1): if self.cost == DoubleBracketCostFunction.off_diagonal_norm: loss = self.off_diagonal_norm elif self.cost == DoubleBracketCostFunction.least_squares: - loss = self.least_squares(d=d) + loss = self.least_squares(d) else: loss = self.energy_fluctuation(self.state) @@ -213,7 +210,9 @@ def energy_fluctuation(self, state): Args: state (np.ndarray): quantum state to be used to compute the energy fluctuation with H. """ - return self.h.energy_fluctuation(state) + state_vector = np.zeros(len(self.h.matrix)) + state_vector[state] = 1.0 + return np.real(self.h.energy_fluctuation(state_vector)) def sigma(self, h: np.array): return h - self.backend.cast(np.diag(np.diag(self.backend.to_numpy(h)))) diff --git a/src/qibo/models/dbi/utils_scheduling.py b/src/qibo/models/dbi/utils_scheduling.py index 2017b57cd1..5f217cc948 100644 --- a/src/qibo/models/dbi/utils_scheduling.py +++ b/src/qibo/models/dbi/utils_scheduling.py @@ -1,12 +1,17 @@ import math from functools import partial from typing import Optional - +from copy import deepcopy import hyperopt import numpy as np + error = 1e-3 +def commutator(A, B): + """Compute commutator between two arrays.""" + return A@B-B@A + def variance(A, state): """Calculates the variance of a matrix A with respect to a state: Var($A$) = $\langle\mu|A^2|\mu\rangle-\langle\mu|A|\mu\rangle^2$""" B = A@A @@ -14,8 +19,8 @@ def variance(A, state): def covariance(A, B, state): """Calculates the covariance of two matrices A and B with respect to a state: Cov($A,B$) = $\langle\mu|AB|\mu\rangle-\langle\mu|A|\mu\rangle\langle\mu|B|\mu\rangle$""" - C = A@B - return C[state,state]-A[state,state]*B[state,state] + C = A@B+B@A + return C[state,state]-2*A[state,state]*B[state,state] def grid_search_step( dbi_object, @@ -44,6 +49,7 @@ def grid_search_step( d = dbi_object.diagonal_h_matrix loss_list = [dbi_object.loss(step, d=d) for step in space] + idx_max_loss = np.argmin(loss_list) return space[idx_max_loss] @@ -83,12 +89,14 @@ def hyperopt_step( d = dbi_object.diagonal_h_matrix space = space("step", step_min, step_max) + + best = hyperopt.fmin( - fn=partial(dbi_object.loss, d=d, look_ahead=look_ahead), - space=space, - algo=optimizer.suggest, - max_evals=max_evals, - verbose=verbose, + fn=partial(dbi_object.loss, d=d, look_ahead=look_ahead), + space=space, + algo=optimizer.suggest, + max_evals=max_evals, + verbose=verbose, ) return best["step"] @@ -112,6 +120,7 @@ def polynomial_step( """ if cost is None: cost = dbi_object.cost.name + if d is None: d = dbi_object.diagonal_h_matrix @@ -135,7 +144,11 @@ def polynomial_step( ] # solution exists, return minimum s if len(real_positive_roots) > 0: - return min(real_positive_roots) + sol = min(real_positive_roots) + for s in real_positive_roots: + if dbi_object.loss(s, d) < dbi_object.loss(sol, d): + sol = s + return sol # solution does not exist, return None else: return None @@ -167,14 +180,13 @@ def least_squares_polynomial_expansion_coef(dbi_object, d, n): if d is None: d = dbi_object.diagonal_h_matrix # generate Gamma's where $\Gamma_{k+1}=[W, \Gamma_{k}], $\Gamma_0=H - W = dbi_object.commutator(d, dbi_object.sigma(dbi_object.h.matrix)) - Gamma_list = dbi_object.generate_Gamma_list(n, d) + Gamma_list = dbi_object.generate_Gamma_list(n+1, d) exp_list = np.array([1 / math.factorial(k) for k in range(n + 1)]) # coefficients coef = np.empty(n) for i in range(n): - coef[i] = exp_list[i]*np.trace(d@Gamma_list[i+1]) - + coef[i] = np.real(exp_list[i]*np.trace(d@Gamma_list[i+1])) + coef = list(reversed(coef)) return coef #TODO: add a general expansion formula not stopping at 3rd order @@ -182,10 +194,67 @@ def energy_fluctuation_polynomial_expansion_coef(dbi_object, d, n, state): if d is None: d = dbi_object.diagonal_h_matrix # generate Gamma's where $\Gamma_{k+1}=[W, \Gamma_{k}], $\Gamma_0=H - Gamma_list = dbi_object.generate_Gamma_list(n, d) + Gamma_list = dbi_object.generate_Gamma_list(n+1, d) # coefficients coef = np.empty(3) - coef[0] = 2*covariance(Gamma_list[0], Gamma_list[1],state) - coef[1] = 2*variance(Gamma_list[1],state) - coef[2] = covariance(Gamma_list[0], Gamma_list[3],state)+3*covariance(Gamma_list[1], Gamma_list[2],state) + coef[0] = np.real(2*covariance(Gamma_list[0], Gamma_list[1],state)) + coef[1] = np.real(2*variance(Gamma_list[1],state)) + coef[2] = np.real(covariance(Gamma_list[0], Gamma_list[3],state)+3*covariance(Gamma_list[1], Gamma_list[2],state)) + coef = list(reversed(coef)) return coef + +def dGamma_diDiagonal(dbi_object, d, H, n, i,dGamma, Gamma_list): + # Derivative of gamma with respect to diagonal elements of D (full-diagonal ansatz) + A = np.zeros(d.shape) + A[i,i] = 1 + B = commutator(commutator(A,H),Gamma_list[n-1]) + W = commutator(d,H) + return B + commutator(W,dGamma[-1]) + +def dpolynomial_diDiagonal(dbi_object, d,H,i): + # Derivative of polynomial approximation of potential function with respect to diagonal elements of d (full-diagonal ansatz) + # Formula can be expanded easily to any order, with n=3 corresponding to cubic approximation + derivative = 0 + s = polynomial_step(dbi_object, n=3, d=d) + A = np.zeros(d.shape) + Gamma_list = dbi_object.generate_Gamma_list(4, d) + A[i,i] = 1 + dGamma = [commutator(A,H)] + derivative += np.real(np.trace(Gamma_list[0]@A)+np.trace(dGamma[0]@d+Gamma_list[1]@A)*s) + for n in range(2,4): + dGamma.append(dGamma_diDiagonal(dbi_object,d,H,n,i,dGamma,Gamma_list)) + derivative += np.real(np.trace(dGamma[-1]@d + Gamma_list[n]@A)*s**n/math.factorial(n)) + + return derivative + +def gradientDiagonal(dbi_object,d,H): + # Gradient of potential function with respect to diagonal elements of D (full-diagonal ansatz) + grad = np.zeros(len(d)) + for i in range(len(d)): + derivative = dpolynomial_diDiagonal(dbi_object,d,H,i) + grad[i] = d[i,i]-derivative + return grad + +def gradient_ascent(dbi_object, d, step, iterations): + H = dbi_object.h.matrix + loss = np.zeros(iterations+1) + grad = np.zeros((iterations,len(d))) + dbi_new = deepcopy(dbi_object) + s = polynomial_step(dbi_object, n = 3, d=d) + dbi_new(s,d=d) + loss[0] = dbi_new(d) + diagonals = np.empty((len(d),iterations+1)) + diagonals[:,0] = np.diag(d) + + for i in range(iterations): + dbi_new = deepcopy(dbi_object) + grad[i,:] = gradientDiagonal(dbi_object, d, H) + for j in range(len(d)): + d[j,j] = d[j,j] - step*grad[i,j] + s = polynomial_step(dbi_object, n = 3, d=d) + dbi_new(s,d=d) + loss[i+1] = dbi_new.least_squares(d) + diagonals[:,i+1] = np.diag(d) + + + return d,loss,grad,diagonals \ No newline at end of file