From eadbc3eb78e56386b0ec944ae44dc207e3bba450 Mon Sep 17 00:00:00 2001 From: Quleaf Date: Thu, 12 Aug 2021 13:27:58 +0800 Subject: [PATCH] update to v2.1.1 --- .gitignore | 139 +- README.md | 8 +- README_CN.md | 8 +- introduction/PaddleQuantum_Tutorial_CN.ipynb | 2 +- introduction/PaddleQuantum_Tutorial_EN.ipynb | 2 +- paddle_quantum/SSVQE/Paddle_SSVQE.py | 55 +- paddle_quantum/circuit.py | 2454 ++++++++++++++--- paddle_quantum/expecval.py | 143 + paddle_quantum/finance.py | 357 +++ paddle_quantum/intrinsic.py | 36 +- paddle_quantum/locc.py | 2 +- paddle_quantum/optimizer/__init__.py | 32 + .../optimizer/conjugate_gradient.py | 62 + paddle_quantum/optimizer/custom_optimizer.py | 108 + paddle_quantum/optimizer/newton_cg.py | 62 + paddle_quantum/optimizer/powell.py | 58 + paddle_quantum/optimizer/slsqp.py | 57 + paddle_quantum/shadow.py | 451 +++ paddle_quantum/simulator.py | 176 +- paddle_quantum/state.py | 20 +- paddle_quantum/utils.py | 886 +++++- requirements.txt | 5 +- setup.py | 4 +- .../ArbitrageOpportunityOptimation_CN.ipynb | 531 ++++ .../ArbitrageOpportunityOptimation_EN.ipynb | 527 ++++ .../PortfolioDiversification_CN.ipynb | 473 ++++ .../PortfolioDiversification_EN.ipynb | 479 ++++ .../PortfolioOptimization_CN.ipynb | 500 ++++ .../PortfolioOptimization_EN.ipynb | 511 ++++ .../combinatorial_optimization/TSP_CN.ipynb | 6 +- .../combinatorial_optimization/TSP_EN.ipynb | 6 +- .../realStockData_12.csv | 37 + .../machine_learning/QClassifier_CN.ipynb | 22 +- .../machine_learning/QClassifier_EN.ipynb | 22 +- tutorial/qnn_research/BarrenPlateaus_CN.ipynb | 28 +- tutorial/qnn_research/BarrenPlateaus_EN.ipynb | 26 +- tutorial/qnn_research/Gradient_CN.ipynb | 917 ++++++ tutorial/qnn_research/Gradient_EN.ipynb | 861 ++++++ tutorial/qnn_research/Noise_CN.ipynb | 40 +- tutorial/quantum_simulation/SSVQE_CN.ipynb | 312 ++- tutorial/quantum_simulation/SSVQE_EN.ipynb | 309 ++- tutorial/quantum_simulation/VQE_CN.ipynb | 4 +- 42 files changed, 9915 insertions(+), 823 deletions(-) create mode 100644 paddle_quantum/expecval.py create mode 100644 paddle_quantum/finance.py create mode 100644 paddle_quantum/optimizer/__init__.py create mode 100644 paddle_quantum/optimizer/conjugate_gradient.py create mode 100644 paddle_quantum/optimizer/custom_optimizer.py create mode 100644 paddle_quantum/optimizer/newton_cg.py create mode 100644 paddle_quantum/optimizer/powell.py create mode 100644 paddle_quantum/optimizer/slsqp.py create mode 100644 paddle_quantum/shadow.py create mode 100644 tutorial/combinatorial_optimization/ArbitrageOpportunityOptimation_CN.ipynb create mode 100644 tutorial/combinatorial_optimization/ArbitrageOpportunityOptimation_EN.ipynb create mode 100644 tutorial/combinatorial_optimization/PortfolioDiversification_CN.ipynb create mode 100644 tutorial/combinatorial_optimization/PortfolioDiversification_EN.ipynb create mode 100644 tutorial/combinatorial_optimization/PortfolioOptimization_CN.ipynb create mode 100644 tutorial/combinatorial_optimization/PortfolioOptimization_EN.ipynb create mode 100644 tutorial/combinatorial_optimization/realStockData_12.csv create mode 100644 tutorial/qnn_research/Gradient_CN.ipynb create mode 100644 tutorial/qnn_research/Gradient_EN.ipynb diff --git a/.gitignore b/.gitignore index 2ac2813..110d28c 100644 --- a/.gitignore +++ b/.gitignore @@ -1,6 +1,139 @@ +# Byte-compiled / optimized / DLL files .idea +.DS_Store +.vscode/ __pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +pip-wheel-metadata/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +.python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# .dat file +*.dat + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# qchem_data folder when run psi4 calculation +qchem_data/ -output -*.egg-info -.ipynb_checkpoints \ No newline at end of file diff --git a/README.md b/README.md index bcd95c4..786a905 100644 --- a/README.md +++ b/README.md @@ -33,7 +33,7 @@ English | [简体中文](README_CN.md) - + @@ -71,7 +71,7 @@ Paddle Quantum aims at establishing a bridge between artificial intelligence (AI ### Install PaddlePaddle -This dependency will be automatically satisfied when users install Paddle Quantum. Please refer to [PaddlePaddle](https://www.paddlepaddle.org.cn/install/quick)'s official installation and configuration page. This project requires PaddlePaddle 2.0.1+. +This dependency will be automatically satisfied when users install Paddle Quantum. Please refer to [PaddlePaddle](https://www.paddlepaddle.org.cn/install/quick)'s official installation and configuration page. This project requires PaddlePaddle 2.1.1+. ### Install Paddle Quantum @@ -147,6 +147,9 @@ We provide tutorials covering quantum simulation, machine learning, combinatoria 2. [Solving Max-Cut Problem with QAOA](./tutorial/combinatorial_optimization/MAXCUT_EN.ipynb) 3. [Large-scale QAOA via Divide-and-Conquer](./tutorial/combinatorial_optimization/DC-QAOA_EN.ipynb) 4. [Travelling Salesman Problem](./tutorial/combinatorial_optimization/TSP_EN.ipynb) + 5. [Quantum Finance Application on Arbitrage Opportunity Optimization](./tutorial/combinatorial_optimization/ArbitrageOpportunityOptimation_EN.ipynb) + 6. [Quantum Finance Application on Portfolio Optimization](./tutorial/combinatorial_optimization/PortfolioOptimization_EN.ipynb) + 7. [Quantum Finance Application on Portfolio Diversification](./tutorial/combinatorial_optimization/PortfolioDiversification_EN.ipynb) - [LOCC with QNN (LOCCNet)](./tutorial/locc) 1. [Local Operations and Classical Communication in QNN (LOCCNet)](./tutorial/locc/LOCCNET_Tutorial_EN.ipynb) @@ -159,6 +162,7 @@ We provide tutorials covering quantum simulation, machine learning, combinatoria - [QNN Research](./tutorial/qnn_research) 1. [The Barren Plateaus Phenomenon on Quantum Neural Networks (Barren Plateaus)](./tutorial/qnn_research/BarrenPlateaus_EN.ipynb) 2. [Noise Model and Quantum Channel](./tutorial/qnn_research/Noise_EN.ipynb) + 3. [Calculating Gradient Using Quantum Circuit](./tutorial/qnn_research/Gradient_EN.ipynb) With the latest LOCCNet module, Paddle Quantum can efficiently simulate distributed quantum information processing tasks. Interested readers can start with this [tutorial on LOCCNet](./tutorial/locc/LOCCNET_Tutorial_EN.ipynb). In addition, Paddle Quantum supports QNN training on GPU. For users who want to get into more details, please check out the tutorial [Use Paddle Quantum on GPU](./introduction/PaddleQuantum_GPU_EN.ipynb). Moreover, Paddle Quantum could design robust quantum algorithms under noise. For more information, please see [Noise tutorial](./tutorial/qnn_research/Noise_EN.ipynb). diff --git a/README_CN.md b/README_CN.md index 27130a5..a9d0178 100644 --- a/README_CN.md +++ b/README_CN.md @@ -34,7 +34,7 @@ - + @@ -71,7 +71,7 @@ ### 安装 PaddlePaddle -当用户安装 Paddle Quantum 时会自动下载安装这个关键依赖包。关于 PaddlePaddle 更全面的安装信息请参考 [PaddlePaddle](https://www.paddlepaddle.org.cn/install/quick) 安装配置页面。此项目需求 PaddlePaddle 2.0.1+。 +当用户安装 Paddle Quantum 时会自动下载安装这个关键依赖包。关于 PaddlePaddle 更全面的安装信息请参考 [PaddlePaddle](https://www.paddlepaddle.org.cn/install/quick) 安装配置页面。此项目需求 PaddlePaddle 2.1.1+。 ### 安装 Paddle Quantum @@ -153,6 +153,9 @@ Paddle Quantum（量桨）建立起了人工智能与量子计算的桥梁，为 2. [QAOA 求解最大割问题](./tutorial/combinatorial_optimization/MAXCUT_CN.ipynb) 3. [大规模量子近似优化分治算法（DC-QAOA）](./tutorial/combinatorial_optimization/DC-QAOA_CN.ipynb) 4. [旅行商问题](./tutorial/combinatorial_optimization/TSP_CN.ipynb) + 5. [量子金融应用：最佳套利机会](./tutorial/combinatorial_optimization/ArbitrageOpportunityOptimation_CN.ipynb) + 6. [量子金融应用：投资组合优化](./tutorial/combinatorial_optimization/PortfolioOptimization_CN.ipynb) + 7. [量子金融应用：投资组合分散化](./tutorial/combinatorial_optimization/PortfolioDiversification_CN.ipynb) - [LOCC 量子神经网络（LOCCNet）](./tutorial/locc) 1. [LOCC 量子神经网络](./tutorial/locc/LOCCNET_Tutorial_CN.ipynb) @@ -165,6 +168,7 @@ Paddle Quantum（量桨）建立起了人工智能与量子计算的桥梁，为 - [量子神经网络研究](./tutorial/qnn_research) 1. [量子神经网络的贫瘠高原效应（Barren Plateaus）](./tutorial/qnn_research/BarrenPlateaus_CN.ipynb) 2. [噪声模型与量子信道](./tutorial/qnn_research/Noise_CN.ipynb) + 3. [使用量子电路计算梯度](./tutorial/qnn_research/Gradient_CN.ipynb) 随着 LOCCNet 模组的推出，量桨现已支持分布式量子信息处理任务的高效模拟和开发。感兴趣的读者请参见[教程](./tutorial/locc/LOCCNET_Tutorial_CN.ipynb)。Paddle Quantum 也支持在 GPU 上进行量子机器学习的训练，具体的方法请参考案例：[在 GPU 上使用 Paddle Quantum](./introduction/PaddleQuantum_GPU_CN.ipynb)。此外，量桨可以基于噪声模块进行含噪算法的开发以及研究，详情请见[噪声模块教程](./tutorial/qnn_research/Noise_CN.ipynb)。 diff --git a/introduction/PaddleQuantum_Tutorial_CN.ipynb b/introduction/PaddleQuantum_Tutorial_CN.ipynb index 3856a22..a3f0f9d 100644 --- a/introduction/PaddleQuantum_Tutorial_CN.ipynb +++ b/introduction/PaddleQuantum_Tutorial_CN.ipynb @@ -981,7 +981,7 @@ "theta = np.random.randn(DEPTH, N, 1)\n", "\n", "# 调用内置的 |00..0> 初始态\n", - "initial_state1 = vec(N)\n", + "initial_state1 = vec(0, N)\n", "# 调用内置的随机量子态 |psi>\n", "initial_state2 = vec_random(N)\n", " \n", diff --git a/introduction/PaddleQuantum_Tutorial_EN.ipynb b/introduction/PaddleQuantum_Tutorial_EN.ipynb index fe14d45..91cceba 100644 --- a/introduction/PaddleQuantum_Tutorial_EN.ipynb +++ b/introduction/PaddleQuantum_Tutorial_EN.ipynb @@ -788,7 +788,7 @@ "theta = np.random.randn(DEPTH, N, 1)\n", "\n", "# Call the built-in |00..0> initial state\n", - "initial_state1 = vec(N)\n", + "initial_state1 = vec(0, N)\n", "# Call the built-in random quantum state |psi>\n", "initial_state2 = vec_random(N)\n", " \n", diff --git a/paddle_quantum/SSVQE/Paddle_SSVQE.py b/paddle_quantum/SSVQE/Paddle_SSVQE.py index d4319a5..8195c68 100644 --- a/paddle_quantum/SSVQE/Paddle_SSVQE.py +++ b/paddle_quantum/SSVQE/Paddle_SSVQE.py @@ -71,15 +71,15 @@ class Net(paddle.nn.Layer): # Use computational basis to calculate each expectation value, which is the same # as a diagonal element in U^dagger*H*U - loss_components = [ - loss_struct[0][0], - loss_struct[1][1], - loss_struct[2][2], - loss_struct[3][3] - ] + loss_components = [] + for i in range(len(loss_struct)): + loss_components.append(loss_struct[i][i]) # Calculate the weighted loss function - loss = 4 * loss_components[0] + 3 * loss_components[1] + 2 * loss_components[2] + 1 * loss_components[3] + loss = 0 + for i in range(len(loss_components)): + weight = 4 - i + loss += weight * loss_components[i] return loss, loss_components @@ -128,17 +128,36 @@ def main(): loss_components = Paddle_SSVQE(H) - print('The estimated ground state energy is: ', loss_components[0].numpy()) - print('The theoretical ground state energy: ', numpy.linalg.eigh(H)[0][0]) - - print('The estimated 1st excited state energy is: ', loss_components[1].numpy()) - print('The theoretical 1st excited state energy: ', numpy.linalg.eigh(H)[0][1]) - - print('The estimated 2nd excited state energy is: ', loss_components[2].numpy()) - print('The theoretical 2nd excited state energy: ', numpy.linalg.eigh(H)[0][2]) - - print('The estimated 3rd excited state energy is: ', loss_components[3].numpy()) - print('The theoretical 3rd excited state energy: ', numpy.linalg.eigh(H)[0][3]) + def output_ordinalvalue(num): + r""" + Convert to ordinal value + + Args: + num (int): input number + + Return: + (str): output ordinal value + """ + if num == 1: + return str(num) + "st" + elif num == 2: + return str(num) + "nd" + elif num == 3: + return str(num) + "rd" + else: + return str(num) + 'th' + + for i in range(len(loss_components)): + if i == 0: + print('The estimated ground state energy is: ', loss_components[i].numpy()) + print('The theoretical ground state energy is: ', numpy.linalg.eigh(H)[0][i]) + else: + print('The estimated {} excited state energy is: {}'.format( + output_ordinalvalue(i), loss_components[i].numpy()) + ) + print('The theoretical {} excited state energy is: {}'.format( + output_ordinalvalue(i), numpy.linalg.eigh(H)[0][i]) + ) if __name__ == '__main__': diff --git a/paddle_quantum/circuit.py b/paddle_quantum/circuit.py index 2783582..071791c 100644 --- a/paddle_quantum/circuit.py +++ b/paddle_quantum/circuit.py @@ -13,21 +13,24 @@ # limitations under the License. import warnings -import numpy as np +import copy import math +import re +import matplotlib.pyplot as plt from functools import reduce from collections import defaultdict -import matplotlib.pyplot as plt -from paddle_quantum.simulator import transfer_state, init_state_gen, measure_state +import numpy as np import paddle -from paddle import matmul, trace, real, imag, reshape -from paddle_quantum.utils import dagger, pauli_str_to_matrix +from paddle_quantum.simulator import transfer_state, init_state_gen, measure_state +from paddle import imag, real, reshape, kron, matmul, trace +from paddle_quantum.utils import partial_trace, dagger, pauli_str_to_matrix +from paddle_quantum import shadow from paddle_quantum.intrinsic import * from paddle_quantum.state import density_op __all__ = [ "UAnsatz", - "H_prob" + "swap_test" ] @@ -45,20 +48,164 @@ class UAnsatz: Args: n (int): 该电路的量子比特数 - """ self.n = n self.__has_channel = False self.__state = None - self.__run_state = '' + self.__run_mode = '' + # Record parameters in the circuit + self.__param = [paddle.to_tensor(np.array([0.0])), + paddle.to_tensor(np.array([math.pi / 2])), paddle.to_tensor(np.array([-math.pi / 2])), + paddle.to_tensor(np.array([math.pi / 4])), paddle.to_tensor(np.array([-math.pi / 4]))] # Record history of adding gates to the circuit self.__history = [] + + def __add__(self, cir): + r"""重载加法 ‘+’ 运算符，用于拼接两个维度相同的电路 + + Args: + cir (UAnsatz): 拼接到现有电路上的电路 + + Returns: + UAnsatz: 拼接后的新电路 + 代码示例: + + .. code-block:: python + + from paddle_quantum.circuit import UAnsatz + + print('cir1: ') + cir1 = UAnsatz(2) + cir1.superposition_layer() + print(cir1) + + print('cir2: ') + cir2 = UAnsatz(2) + cir2.cnot([0,1]) + print(cir2) + + print('cir3: ') + cir3 = cir1 + cir2 + print(cir3) + :: + + cir1: + --H-- + + --H-- + + cir2: + --*-- + | + --x-- + + cir3: + --H----*-- + | + --H----x-- + + """ + assert self.n == cir.n, "two circuits does not have the same dimension" + + # Construct a new circuit that adds the two together + cir_out = UAnsatz(self.n) + cir_out.__param = copy.copy(self.__param) + cir_out.__history = copy.copy(self.__history) + cir_out._add_history(cir.__history, cir.__param) + + return cir_out + + def _get_history(self): + r"""获取当前电路加门的历史 + + Note: + 这是内部函数，你并不需要直接调用到该函数。 + """ + return self.__history, self.__param + + def _add_history(self, histories, param): + r"""往当前 UAnsatz 里直接添加历史 + + Note: + 这是内部函数，你并不需要直接调用到该函数。 + """ + if type(histories) is dict: + histories = [histories] + + for history_ele in histories: + param_idx = history_ele['theta'] + if param_idx is None: + self.__history.append(copy.copy(history_ele)) + else: + new_param_idx = [] + curr_idx = len(self.__param) + for idx in param_idx: + self.__param.append(param[idx]) + new_param_idx.append(curr_idx) + curr_idx += 1 + self.__history.append({'gate': history_ele['gate'], + 'which_qubits': history_ele['which_qubits'], + 'theta': new_param_idx}) + + def get_run_mode(self): + r"""获取当前电路的运行模式。 + + Returns: + string: 当前电路的运行模式，态矢量或者是密度矩阵 + + 代码示例: + + .. code-block:: python + + import paddle + from paddle_quantum.circuit import UAnsatz + import numpy as np + + cir = UAnsatz(5) + cir.superposition_layer() + cir.run_state_vector() + + print(cir.get_run_mode()) + + :: + + state_vector + """ + return self.__run_mode + + def get_state(self): + r"""获取当前电路运行后的态 + + Returns: + paddle.Tensor: 当前电路运行后的态 + + 代码示例: + + .. code-block:: python + + import paddle + from paddle_quantum.circuit import UAnsatz + import numpy as np + + cir = UAnsatz(5) + cir.superposition_layer() + cir.run_state_vector() + + print(cir.get_state()) + + :: + + Tensor(shape=[4], dtype=complex128, place=CPUPlace, stop_gradient=True, + [(0.4999999999999999+0j), (0.4999999999999999+0j), (0.4999999999999999+0j), (0.4999999999999999+0j)]) + """ + return self.__state + def _count_history(self): r"""calculate how many blocks needed for printing Note: - 这是内部函数，你并不需要直接调用到该函数。 + 这是内部函数，你并不需要直接调用到该函数。 """ # Record length of each section length = [5] @@ -70,11 +217,11 @@ class UAnsatz: # Record section number for each gate gate = [] history = self.__history - + for current_gate in history: # Single-qubit gates with no params to print - if current_gate[0] in {'h', 's', 't', 'x', 'y', 'z', 'u'}: - curr_qubit = current_gate[1][0] + if current_gate['gate'] in {'h', 's', 't', 'x', 'y', 'z', 'u', 'sdg', 'tdg'}: + curr_qubit = current_gate['which_qubits'][0] gate.append(qubit[curr_qubit]) qubit[curr_qubit] = qubit[curr_qubit] + 1 # A new section is added @@ -82,8 +229,8 @@ class UAnsatz: length.append(5) qubit_max = qubit[curr_qubit] # Gates with params to print - elif current_gate[0] in {'rx', 'ry', 'rz'}: - curr_qubit = current_gate[1][0] + elif current_gate['gate'] in {'rx', 'ry', 'rz'}: + curr_qubit = current_gate['which_qubits'][0] gate.append(qubit[curr_qubit]) if length[qubit[curr_qubit]] == 5: length[qubit[curr_qubit]] = 13 @@ -91,30 +238,30 @@ class UAnsatz: if qubit[curr_qubit] > qubit_max: length.append(5) qubit_max = qubit[curr_qubit] - # Two-qubit gates - elif current_gate[0] in {'CNOT', 'SWAP', 'RXX_gate', 'RYY_gate', 'RZZ_gate', 'MS_gate'}: - p = current_gate[1][0] - q = current_gate[1][1] - a = max(p, q) - b = min(p, q) + # Two-qubit gates or Three-qubit gates + elif current_gate['gate'] in {'CNOT', 'SWAP', 'RXX_gate', 'RYY_gate', 'RZZ_gate', 'MS_gate', 'cy', 'cz', + 'CU', 'crx', 'cry', 'crz'} or current_gate['gate'] in {'CSWAP', 'CCX'}: + a = max(current_gate['which_qubits']) + b = min(current_gate['which_qubits']) ind = max(qubit[b: a + 1]) gate.append(ind) - if length[ind] < 13 and current_gate[0] in {'RXX_gate', 'RYY_gate', 'RZZ_gate'}: + if length[ind] < 13 and current_gate['gate'] in {'RXX_gate', 'RYY_gate', 'RZZ_gate', 'crx', 'cry', + 'crz'}: length[ind] = 13 for j in range(b, a + 1): qubit[j] = ind + 1 if ind + 1 > qubit_max: length.append(5) qubit_max = ind + 1 - + return length, gate - + def __str__(self): r"""实现画电路的功能 - + Returns: string: 用来print的字符串 - + 代码示例: .. code-block:: python @@ -122,17 +269,17 @@ class UAnsatz: import paddle from paddle_quantum.circuit import UAnsatz import numpy as np - + cir = UAnsatz(5) cir.superposition_layer() rotations = paddle.to_tensor(np.random.uniform(-2, 2, size=(3, 5, 1))) cir.real_entangled_layer(rotations, 3) - + print(cir) :: - + The printed circuit is: - + --H----Ry(-0.14)----*-------------------X----Ry(-0.77)----*-------------------X-- | | | | --H----Ry(-1.00)----X----*--------------|----Ry(-0.83)----X----*--------------|-- @@ -142,76 +289,126 @@ class UAnsatz: --H----Ry(1.024)--------------X----*----|----Ry(-0.37)--------------X----*----|-- | | | | --H----Ry(1.905)-------------------X----*----Ry(-1.82)-------------------X----*-- - """ length, gate = self._count_history() history = self.__history n = self.n - # Ignore the unused section + # Ignore the unused section total_length = sum(length) - 5 - + print_list = [['-' if i % 2 == 0 else ' '] * total_length for i in range(n * 2)] for i, current_gate in enumerate(history): - if current_gate[0] in {'h', 's', 't', 'x', 'y', 'z', 'u'}: + if current_gate['gate'] in {'h', 's', 't', 'x', 'y', 'z', 'u'}: # Calculate starting position ind of current gate sec = gate[i] ind = sum(length[:sec]) - print_list[current_gate[1][0] * 2][ind + length[sec] // 2] = current_gate[0].upper() - elif current_gate[0] in {'rx', 'ry', 'rz'}: + print_list[current_gate['which_qubits'][0] * 2][ind + length[sec] // 2] = current_gate['gate'].upper() + elif current_gate['gate'] in {'sdg'}: + sec = gate[i] + ind = sum(length[:sec]) + print_list[current_gate['which_qubits'][0] * 2][ + ind + length[sec] // 2 - 1: ind + length[sec] // 2 + 2] = current_gate['gate'].upper() + elif current_gate['gate'] in {'tdg'}: + sec = gate[i] + ind = sum(length[:sec]) + print_list[current_gate['which_qubits'][0] * 2][ + ind + length[sec] // 2 - 1: ind + length[sec] // 2 + 2] = current_gate['gate'].upper() + elif current_gate['gate'] in {'rx', 'ry', 'rz'}: sec = gate[i] ind = sum(length[:sec]) - line = current_gate[1][0] * 2 - param = current_gate[2][2 if current_gate[0] == 'rz' else 0] + line = current_gate['which_qubits'][0] * 2 + param = self.__param[current_gate['theta'][2 if current_gate['gate'] == 'rz' else 0]] print_list[line][ind + 2] = 'R' - print_list[line][ind + 3] = current_gate[0][1] + print_list[line][ind + 3] = current_gate['gate'][1] print_list[line][ind + 4] = '(' print_list[line][ind + 5: ind + 10] = format(float(param.numpy()), '.3f')[:5] print_list[line][ind + 10] = ')' - elif current_gate[0] in {'CNOT', 'SWAP', 'RXX_gate', 'RYY_gate', 'RZZ_gate', 'MS_gate'}: + # Two-qubit gates + elif current_gate['gate'] in {'CNOT', 'SWAP', 'RXX_gate', 'RYY_gate', 'RZZ_gate', 'MS_gate', 'cz', 'cy', + 'CU', 'crx', 'cry', 'crz'}: sec = gate[i] ind = sum(length[:sec]) - cqubit = current_gate[1][0] - tqubit = current_gate[1][1] - if current_gate[0] in {'CNOT', 'SWAP'}: - print_list[cqubit * 2][ind + length[sec] // 2] = '*' - print_list[tqubit * 2][ind + length[sec] // 2] = 'X' if current_gate[0] == 'CNOT' else '*' - elif current_gate[0] == 'MS_gate': + cqubit = current_gate['which_qubits'][0] + tqubit = current_gate['which_qubits'][1] + if current_gate['gate'] in {'CNOT', 'SWAP', 'cy', 'cz', 'CU'}: + print_list[cqubit * 2][ind + length[sec] // 2] = \ + '*' if current_gate['gate'] in {'CNOT', 'cy', 'cz', 'CU'} else 'x' + print_list[tqubit * 2][ind + length[sec] // 2] = \ + 'x' if current_gate['gate'] in {'SWAP', 'CNOT'} else current_gate['gate'][1] + elif current_gate['gate'] == 'MS_gate': for qubit in {cqubit, tqubit}: print_list[qubit * 2][ind + length[sec] // 2 - 1] = 'M' print_list[qubit * 2][ind + length[sec] // 2] = '_' print_list[qubit * 2][ind + length[sec] // 2 + 1] = 'S' - elif current_gate[0] in {'RXX_gate', 'RYY_gate', 'RZZ_gate'}: - param = current_gate[2] + elif current_gate['gate'] in {'RXX_gate', 'RYY_gate', 'RZZ_gate'}: + param = self.__param[current_gate['theta'][0]] for line in {cqubit * 2, tqubit * 2}: print_list[line][ind + 2] = 'R' - print_list[line][ind + 3: ind + 5] = current_gate[0][1:3].lower() + print_list[line][ind + 3: ind + 5] = current_gate['gate'][1:3].lower() print_list[line][ind + 5] = '(' print_list[line][ind + 6: ind + 10] = format(float(param.numpy()), '.2f')[:4] print_list[line][ind + 10] = ')' + elif current_gate['gate'] in {'crx', 'cry', 'crz'}: + param = self.__param[current_gate['theta'][2 if current_gate['gate'] == 'crz' else 0]] + print_list[cqubit * 2][ind + length[sec] // 2] = '*' + print_list[tqubit * 2][ind + 2] = 'R' + print_list[tqubit * 2][ind + 3] = current_gate['gate'][2] + print_list[tqubit * 2][ind + 4] = '(' + print_list[tqubit * 2][ind + 5: ind + 10] = format(float(param.numpy()), '.3f')[:5] + print_list[tqubit * 2][ind + 10] = ')' start_line = min(cqubit, tqubit) end_line = max(cqubit, tqubit) for k in range(start_line * 2 + 1, end_line * 2): print_list[k][ind + length[sec] // 2] = '|' + # Three-qubit gates + elif current_gate['gate'] in {'CSWAP'}: + sec = gate[i] + ind = sum(length[:sec]) + cqubit = current_gate['which_qubits'][0] + tqubit1 = current_gate['which_qubits'][1] + tqubit2 = current_gate['which_qubits'][2] + start_line = min(current_gate['which_qubits']) + end_line = max(current_gate['which_qubits']) + for k in range(start_line * 2 + 1, end_line * 2): + print_list[k][ind + length[sec] // 2] = '|' + if current_gate['gate'] in {'CSWAP'}: + print_list[cqubit * 2][ind + length[sec] // 2] = '*' + print_list[tqubit1 * 2][ind + length[sec] // 2] = 'x' + print_list[tqubit2 * 2][ind + length[sec] // 2] = 'x' + elif current_gate['gate'] in {'CCX'}: + sec = gate[i] + ind = sum(length[:sec]) + cqubit1 = current_gate['which_qubits'][0] + cqubit2 = current_gate['which_qubits'][1] + tqubit = current_gate['which_qubits'][2] + start_line = min(current_gate['which_qubits']) + end_line = max(current_gate['which_qubits']) + for k in range(start_line * 2 + 1, end_line * 2): + print_list[k][ind + length[sec] // 2] = '|' + if current_gate['gate'] in {'CCX'}: + print_list[cqubit1 * 2][ind + length[sec] // 2] = '*' + print_list[cqubit2 * 2][ind + length[sec] // 2] = '*' + print_list[tqubit * 2][ind + length[sec] // 2] = 'X' print_list = list(map(''.join, print_list)) return_str = '\n'.join(print_list) return return_str - + def run_state_vector(self, input_state=None, store_state=True): r"""运行当前的量子电路，输入输出的形式为态矢量。 Warning: 该方法只能运行无噪声的电路。 - + Args: input_state (Tensor, optional): 输入的态矢量，默认为 :math:`|00...0\rangle` store_state (Bool, optional): 是否存储输出的态矢量，默认为 ``True`` ，即存储 - + Returns: Tensor: 量子电路输出的态矢量 - + 代码示例: .. code-block:: python @@ -223,7 +420,7 @@ class UAnsatz: n = 2 theta = np.ones(3) - input_state = paddle.to_tensor(vec(n)) + input_state = paddle.to_tensor(vec(0, n)) theta = paddle.to_tensor(theta) cir = UAnsatz(n) cir.h(0) @@ -241,29 +438,30 @@ class UAnsatz: warnings.warn('The noiseless circuit will be run.', RuntimeWarning) state = init_state_gen(self.n, 0) if input_state is None else input_state old_shape = state.shape - assert reduce(lambda x, y: x * y, old_shape) == 2 ** self.n, 'The length of the input vector is not right' + assert reduce(lambda x, y: x * y, old_shape) == 2 ** self.n, \ + 'The length of the input vector is not right' state = reshape(state, (2 ** self.n,)) state_conj = paddle.conj(state) assert paddle.abs(real(paddle.sum(paddle.multiply(state_conj, state))) - 1) < 1e-8, \ 'Input state is not a normalized vector' - state = transfer_by_history(state, self.__history) + state = transfer_by_history(state, self.__history, self.__param) if store_state: self.__state = state # Add info about which function user called - self.__run_state = 'state_vector' + self.__run_mode = 'state_vector' return reshape(state, old_shape) def run_density_matrix(self, input_state=None, store_state=True): r"""运行当前的量子电路，输入输出的形式为密度矩阵。 - + Args: input_state (Tensor, optional): 输入的密度矩阵，默认为 :math:`|00...0\rangle \langle00...0|` store_state (bool, optional): 是否存储输出的密度矩阵，默认为 ``True`` ，即存储 - + Returns: Tensor: 量子电路输出的密度矩阵 @@ -294,7 +492,8 @@ class UAnsatz: [0.47686058-0.03603751j 0.35403671+0.j ]] """ state = paddle.to_tensor(density_op(self.n)) if input_state is None else input_state - assert state.shape == [2 ** self.n, 2 ** self.n], "The dimension is not right" + assert state.shape == [2 ** self.n, 2 ** self.n], \ + "The dimension is not right" if not self.__has_channel: state = matmul(self.U, matmul(state, dagger(self.U))) @@ -307,35 +506,85 @@ class UAnsatz: identity = reshape(identity, [num_ele]) u_start = 0 + i = 0 for i, history_ele in enumerate(self.__history): - if history_ele[0] == 'channel': + if history_ele['gate'] == 'channel': # Combine preceding unitary operations - unitary = transfer_by_history(identity, self.__history[u_start:i]) + unitary = transfer_by_history(identity, self.__history[u_start:i], self.__param) sub_state = paddle.zeros(shape, dtype='complex128') # Sum all the terms corresponding to different Kraus operators - for op in history_ele[1]: - pseudo_u = reshape(transfer_state(unitary, op, history_ele[2]), shape) - sub_state += pseudo_u @ state @ dagger(pseudo_u) + for op in history_ele['operators']: + pseudo_u = reshape(transfer_state(unitary, op, history_ele['which_qubits']), shape) + sub_state += matmul(pseudo_u, matmul(state, dagger(pseudo_u))) state = sub_state u_start = i + 1 # Apply unitary operations left - unitary = reshape(transfer_by_history(identity, self.__history[u_start:(i + 1)]), shape) + unitary = reshape(transfer_by_history(identity, self.__history[u_start:(i + 1)], self.__param), shape) state = matmul(unitary, matmul(state, dagger(unitary))) if store_state: self.__state = state # Add info about which function user called - self.__run_state = 'density_matrix' + self.__run_mode = 'density_matrix' return state + def reset_state(self, state, which_qubits): + r"""对当前电路中的量子态的部分量子比特进行重置。 + + Args: + state (paddle.Tensor): 输入的量子态，表示要把选定的量子比特重置为该量子态 + which_qubits (list): 需要被重置的量子比特编号 + """ + qubits_list = which_qubits + n = self.n + m = len(qubits_list) + assert max(qubits_list) <= n, "qubit index out of range" + + origin_seq = list(range(0, n)) + target_seq = [idx for idx in origin_seq if idx not in qubits_list] + target_seq = qubits_list + target_seq + + swapped = [False] * n + swap_list = list() + for idx in range(0, n): + if not swapped[idx]: + next_idx = idx + swapped[next_idx] = True + while not swapped[target_seq[next_idx]]: + swapped[target_seq[next_idx]] = True + swap_list.append((next_idx, target_seq[next_idx])) + next_idx = target_seq[next_idx] + + cir0 = UAnsatz(n) + for a, b in swap_list: + cir0.swap([a, b]) + + cir1 = UAnsatz(n) + swap_list.reverse() + for a, b in swap_list: + cir1.swap([a, b]) + + _state = self.__state + + if self.__run_mode == 'state_vector': + raise NotImplementedError('This feature is not implemented yet.') + elif self.__run_mode == 'density_matrix': + _state = cir0.run_density_matrix(_state) + _state = partial_trace(_state, 2 ** m, 2 ** (n - m), 1) + _state = kron(state, _state) + _state = cir1.run_density_matrix(_state) + else: + raise ValueError("Can't recognize the mode of quantum state.") + self.__state = _state + @property def U(self): r"""量子电路的酉矩阵形式。 Warning: 该属性只限于无噪声的电路。 - + Returns: Tensor: 当前电路的酉矩阵表示 @@ -369,11 +618,34 @@ class UAnsatz: state = paddle.eye(dim, dtype='float64') state = paddle.cast(state, 'complex128') state = reshape(state, [num_ele]) - state = transfer_by_history(state, self.__history) + state = transfer_by_history(state, self.__history, self.__param) return reshape(state, shape) - def basis_encoding(self, x, invert=False): + def __input_which_qubits_check(self, which_qubits): + r"""实现3个功能： + + 1. 检查 which_qubits 长度有无超过 qubits 的个数, (应小于等于qubits) + 2. 检查 which_qubits 有无重复的值 + 3. 检查 which_qubits 的每个值有无超过量子 qubits 的序号, (应小于qubits,从 0 开始编号) + + Args: + which_qubits (list) : 用于编码的量子比特 + + Note: + 这是内部函数，你并不需要直接调用到该函数。 + """ + which_qubits_len = len(which_qubits) + set_list = set(which_qubits) + assert which_qubits_len <= self.n, \ + "the length of which_qubit_list should less than the number of qubits" + assert which_qubits_len == len(set_list), \ + "the which_qubits can not have duplicate elements" + for qubit_idx in which_qubits: + assert qubit_idx < self.n, \ + "the value of which_qubit_list should less than the number of qubits" + + def basis_encoding(self, x, which_qubits=None, invert=False): r"""将输入的经典数据使用基态编码的方式编码成量子态。 在 basis encoding 中，输入的经典数据只能包括 0 或 1。如输入数据为 1101，则编码后的量子态为 :math:`|1101\rangle` 。 @@ -381,68 +653,148 @@ class UAnsatz: Args: x (Tensor): 待编码的向量 + which_qubits (list): 用于编码的量子比特 invert (bool): 添加的是否为编码电路的逆电路，默认为 ``False`` ，即添加正常的编码电路 """ x = paddle.flatten(x) x = paddle.cast(x, dtype="int32") - assert x.size == self.n, "the number of classical data should be equal to the number of qubits" + assert x.size <= self.n, \ + "the number of classical data should less than or equal to the number of qubits" + if which_qubits is None: + which_qubits = list(range(self.n)) + else: + self.__input_which_qubits_check(which_qubits) + assert x.size <= len(which_qubits), \ + "the number of classical data should less than or equal to the number of 'which_qubits'" + for idx, element in enumerate(x): if element: - self.x(idx) + self.x(which_qubits[idx]) - def amplitude_encoding(self, x, mode): + def amplitude_encoding(self, x, mode, which_qubits=None): r"""将输入的经典数据使用振幅编码的方式编码成量子态。 Args: x (Tensor): 待编码的向量 + which_qubits (list): 用于编码的量子比特 mode (str): 生成的量子态的表示方式，``"state_vector"`` 代表态矢量表示， ``"density_matrix"`` 代表密度矩阵表示 Returns: Tensor: 一个形状为 ``(2 ** n, )`` 或 ``(2 ** n, 2 ** n)`` 的张量，表示编码之后的量子态。 """ - assert x.size <= 2 ** self.n, "the number of classical data should be equal to the number of qubits" + assert x.size <= 2 ** self.n, \ + "the number of classical data should less than or equal to the number of qubits" + + if which_qubits is None: + which_qubits_len = math.ceil(math.log2(x.size)) + which_qubits = list(range(which_qubits_len)) + else: + self.__input_which_qubits_check(which_qubits) + which_qubits_len = len(which_qubits) + assert x.size <= 2 ** which_qubits_len, \ + "the number of classical data should <= 2^(which_qubits)" + assert x.size > 2 ** (which_qubits_len - 1), \ + "the number of classical data should >= 2^(which_qubits-1)" + + def calc_location(location_of_bits_list): + r"""递归计算需要参与编码的量子态展开后的序号 + 方式：全排列，递归计算 + + Args: + location_of_bits_list (list): 标识了指定 qubits 的序号值，如指定编码第3个qubit(序号2)， + 则它处在展开后的 2**(3-1)=4 位置上。 + + Returns: + list : 标识了将要参与编码的量子位展开后的序号 + """ + if len(location_of_bits_list) <= 1: + result_list = [0, location_of_bits_list[0]] + else: + current_tmp = location_of_bits_list[0] + inner_location_of_qubits_list = calc_location(location_of_bits_list[1:]) + current_list_len = len(inner_location_of_qubits_list) + for each in range(current_list_len): + inner_location_of_qubits_list.append(inner_location_of_qubits_list[each] + current_tmp) + result_list = inner_location_of_qubits_list + + return result_list + + def encoding_location_list(which_qubits): + r"""计算每一个经典数据将要编码到量子态展开后的哪一个位置 + + Args: + which_qubits (list): 标识了参与编码的量子 qubits 的序号, 此参数与外部 which_qubits 参数应保持一致 + + Returns: + (list) : 将要参与编码的量子 qubits 展开后的序号，即位置序号 + """ + location_of_bits_list = [] + for each in range(len(which_qubits)): + tmp = 2 ** (self.n - which_qubits[each] - 1) + location_of_bits_list.append(tmp) + result_list = calc_location(location_of_bits_list) + + return sorted(result_list) + + # Get the specific position of the code, denoted by sequence number (list) + location_of_qubits_list = encoding_location_list(which_qubits) + # Classical data preprocessing x = paddle.flatten(x) - pad_num = 2 ** self.n - x.size - if pad_num > 0: - zero_tensor = paddle.zeros((pad_num,), x.dtype) - x = paddle.concat([x, zero_tensor]) length = paddle.norm(x, p=2) + # Normalization x = paddle.divide(x, length) + # Create a quantum state with all zero amplitudes + zero_tensor = paddle.zeros((2 ** self.n,), x.dtype) + # The value of the encoded amplitude is filled into the specified qubits + for i in range(len(x)): + zero_tensor[location_of_qubits_list[i]] = x[i] + # The quantum state that stores the result + result_tensor = zero_tensor if mode == "state_vector": - x = paddle.cast(x, dtype="complex128") + result_tensor = paddle.cast(result_tensor, dtype="complex128") elif mode == "density_matrix": - x = paddle.reshape(x, (2**self.n, 1)) - x = matmul(x, dagger(x)) + result_tensor = paddle.reshape(result_tensor, (2 ** self.n, 1)) + result_tensor = matmul(result_tensor, dagger(result_tensor)) else: raise ValueError("the mode should be state_vector or density_matrix") - return x - def angle_encoding(self, x, encoding_gate, invert=False): + return result_tensor + + def angle_encoding(self, x, encoding_gate, which_qubits=None, invert=False): r"""将输入的经典数据使用角度编码的方式进行编码。 Args: x (Tensor): 待编码的向量 encoding_gate (str): 编码要用的量子门，可以是 ``"rx"`` 、 ``"ry"`` 和 ``"rz"`` + which_qubits (list): 用于编码的量子比特 invert (bool): 添加的是否为编码电路的逆电路，默认为 ``False`` ，即添加正常的编码电路 """ - assert x.size <= self.n, "the number of classical data should be equal to the number of qubits" + assert x.size <= self.n, \ + "the number of classical data should be equal to the number of qubits" + if which_qubits is None: + which_qubits = list(range(self.n)) + else: + self.__input_which_qubits_check(which_qubits) + assert x.size <= len(which_qubits), \ + "the number of classical data should less than or equal to the number of 'which_qubits'" + x = paddle.flatten(x) if invert: x = -x - def add_encoding_gate(theta, idx, gate): + def add_encoding_gate(theta, which, gate): if gate == "rx": - self.rx(theta, idx) + self.rx(theta, which) elif gate == "ry": - self.ry(theta, idx) + self.ry(theta, which) elif gate == "rz": - self.rz(theta, idx) + self.rz(theta, which) else: raise ValueError("the encoding_gate should be rx, ry, or rz") for idx, element in enumerate(x): - add_encoding_gate(element[0], idx, encoding_gate) + add_encoding_gate(element[0], which_qubits[idx], encoding_gate) def iqp_encoding(self, x, num_repeats=1, pattern=None, invert=False): r"""将输入的经典数据使用 IQP 编码的方式进行编码。 @@ -453,7 +805,8 @@ class UAnsatz: pattern (list): 量子比特的纠缠方式 invert (bool): 添加的是否为编码电路的逆电路，默认为 ``False`` ，即添加正常的编码电路 """ - assert x.size <= self.n, "the number of classical data should be equal to the number of qubits" + assert x.size <= self.n, \ + "the number of classical data should be equal to the number of qubits" num_x = x.size x = paddle.flatten(x) if pattern is None: @@ -467,7 +820,7 @@ class UAnsatz: if invert: for item in pattern: self.cnot(list(item)) - self.rz(-x[item[0]]*x[item[1]], item[1]) + self.rz(-x[item[0]] * x[item[1]], item[1]) self.cnot(list(item)) for idx in range(0, num_x): self.rz(-x[idx], idx) @@ -480,7 +833,7 @@ class UAnsatz: self.rz(x[idx], idx) for item in pattern: self.cnot(list(item)) - self.rz(x[item[0]]*x[item[1]], item[1]) + self.rz(x[item[0]] * x[item[1]], item[1]) self.cnot(list(item)) """ @@ -491,10 +844,13 @@ class UAnsatz: r"""添加关于 x 轴的单量子比特旋转门。 其矩阵形式为： - + .. math:: - - \begin{bmatrix} \cos\frac{\theta}{2} & -i\sin\frac{\theta}{2} \\ -i\sin\frac{\theta}{2} & \cos\frac{\theta}{2} \end{bmatrix} + + \begin{bmatrix} + \cos\frac{\theta}{2} & -i\sin\frac{\theta}{2} \\ + -i\sin\frac{\theta}{2} & \cos\frac{\theta}{2} + \end{bmatrix} Args: theta (Tensor): 旋转角度 @@ -513,26 +869,73 @@ class UAnsatz: cir.rx(theta[0], which_qubit) """ - assert 0 <= which_qubit < self.n, "the qubit should >= 0 and < n (the number of qubit)" - self.__history.append(['rx', [which_qubit], [theta, - paddle.to_tensor(np.array([-math.pi / 2])), - paddle.to_tensor(np.array([math.pi / 2]))]]) + assert 0 <= which_qubit < self.n, \ + "the qubit should >= 0 and < n (the number of qubit)" + curr_idx = len(self.__param) + self.__history.append({'gate': 'rx', 'which_qubits': [which_qubit], 'theta': [curr_idx, 2, 1]}) + self.__param.append(theta) + + def crx(self, theta, which_qubit): + r"""添加关于 x 轴的控制单量子比特旋转门。 + + 其矩阵形式为： + + .. math:: + + \begin{align} + CNOT &=|0\rangle \langle 0|\otimes I + |1 \rangle \langle 1|\otimes rx\\ + &= + \begin{bmatrix} + 1 & 0 & 0 & 0 \\ + 0 & 1 & 0 & 0 \\ + 0 & 0 & \cos\frac{\theta}{2} & -i\sin\frac{\theta}{2} \\ + 0 & 0 & -i\sin\frac{\theta}{2} & \cos\frac{\theta}{2} + \end{bmatrix} + \end{align} + + Args: + theta (Tensor): 旋转角度 + which_qubit (list): 作用在的 qubit 的编号，其值应该在 :math:`[0, n)` 范围内， :math:`n` 为该量子电路的量子比特数 + + .. code-block:: python + + import numpy as np + import paddle + from paddle_quantum.circuit import UAnsatz + theta = np.array([np.pi], np.float64) + theta = paddle.to_tensor(theta) + num_qubits = 2 + cir = UAnsatz(num_qubits) + which_qubit = [0, 1] + cir.crx(theta[0], which_qubit) + + """ + assert 0 <= which_qubit[0] < self.n and 0 <= which_qubit[1] < self.n, \ + "the qubit should >= 0 and < n (the number of qubit)" + assert which_qubit[0] != which_qubit[1], \ + "the control qubit is the same as the target qubit" + curr_idx = len(self.__param) + self.__history.append({'gate': 'crx', 'which_qubits': which_qubit, 'theta': [curr_idx, 2, 1]}) + self.__param.append(theta) def ry(self, theta, which_qubit): r"""添加关于 y 轴的单量子比特旋转门。 其矩阵形式为： - + .. math:: - - \begin{bmatrix} \cos\frac{\theta}{2} & -\sin\frac{\theta}{2} \\ \sin\frac{\theta}{2} & \cos\frac{\theta}{2} \end{bmatrix} + + \begin{bmatrix} + \cos\frac{\theta}{2} & -\sin\frac{\theta}{2} \\ + \sin\frac{\theta}{2} & \cos\frac{\theta}{2} + \end{bmatrix} Args: theta (Tensor): 旋转角度 which_qubit (int): 作用在的 qubit 的编号，其值应该在 :math:`[0, n)` 范围内， :math:`n` 为该量子电路的量子比特数 .. code-block:: python - + import numpy as np import paddle from paddle_quantum.circuit import UAnsatz @@ -543,26 +946,72 @@ class UAnsatz: which_qubit = 0 cir.ry(theta[0], which_qubit) """ - assert 0 <= which_qubit < self.n, "the qubit should >= 0 and < n (the number of qubit)" - self.__history.append(['ry', [which_qubit], [theta, - paddle.to_tensor(np.array([0.0])), - paddle.to_tensor(np.array([0.0]))]]) + assert 0 <= which_qubit < self.n, \ + "the qubit should >= 0 and < n (the number of qubit)" + curr_idx = len(self.__param) + self.__history.append({'gate': 'ry', 'which_qubits': [which_qubit], 'theta': [curr_idx, 0, 0]}) + self.__param.append(theta) + + def cry(self, theta, which_qubit): + r"""添加关于 y 轴的控制单量子比特旋转门。 + + 其矩阵形式为： + + .. math:: + + \begin{align} + CNOT &=|0\rangle \langle 0|\otimes I + |1 \rangle \langle 1|\otimes rx\\ + &= + \begin{bmatrix} + 1 & 0 & 0 & 0 \\ + 0 & 1 & 0 & 0 \\ + 0 & 0 & \cos\frac{\theta}{2} & -\sin\frac{\theta}{2} \\ + 0 & 0 & \sin\frac{\theta}{2} & \cos\frac{\theta}{2} + \end{bmatrix} + \end{align} + + Args: + theta (Tensor): 旋转角度 + which_qubit (list): 作用在的 qubit 的编号，其值应该在 :math:`[0, n)` 范围内， :math:`n` 为该量子电路的量子比特数 + + .. code-block:: python + + import numpy as np + import paddle + from paddle_quantum.circuit import UAnsatz + theta = np.array([np.pi], np.float64) + theta = paddle.to_tensor(theta) + num_qubits = 2 + cir = UAnsatz(num_qubits) + which_qubit = [0, 1] + cir.cry(theta[0], which_qubit) + """ + assert 0 <= which_qubit[0] < self.n and 0 <= which_qubit[1] < self.n, \ + "the qubit should >= 0 and < n (the number of qubit)" + assert which_qubit[0] != which_qubit[1], \ + "the control qubit is the same as the target qubit" + curr_idx = len(self.__param) + self.__history.append({'gate': 'cry', 'which_qubits': which_qubit, 'theta': [curr_idx, 0, 0]}) + self.__param.append(theta) def rz(self, theta, which_qubit): r"""添加关于 z 轴的单量子比特旋转门。 其矩阵形式为： - + .. math:: - \begin{bmatrix} 1 & 0 \\ 0 & e^{i\theta} \end{bmatrix} + \begin{bmatrix} + 1 & 0 \\ + 0 & e^{i\theta} + \end{bmatrix} Args: theta (Tensor): 旋转角度 which_qubit (int): 作用在的 qubit 的编号，其值应该在 :math:`[0, n)` 范围内， :math:`n` 为该量子电路的量子比特数 .. code-block:: python - + import numpy as np import paddle from paddle_quantum.circuit import UAnsatz @@ -573,10 +1022,53 @@ class UAnsatz: which_qubit = 0 cir.rz(theta[0], which_qubit) """ - assert 0 <= which_qubit < self.n, "the qubit should >= 0 and < n (the number of qubit)" - self.__history.append(['rz', [which_qubit], [paddle.to_tensor(np.array([0.0])), - paddle.to_tensor(np.array([0.0])), - theta]]) + assert 0 <= which_qubit < self.n, \ + "the qubit should >= 0 and < n (the number of qubit)" + curr_idx = len(self.__param) + self.__history.append({'gate': 'rz', 'which_qubits': [which_qubit], 'theta': [0, 0, curr_idx]}) + self.__param.append(theta) + + def crz(self, theta, which_qubit): + r"""添加关于 z 轴的控制单量子比特旋转门。 + + 其矩阵形式为： + + .. math:: + + \begin{align} + CNOT &=|0\rangle \langle 0|\otimes I + |1 \rangle \langle 1|\otimes rx\\ + &= + \begin{bmatrix} + 1 & 0 & 0 & 0 \\ + 0 & 1 & 0 & 0 \\ + 0 & 0 & 1 & 0 \\ + 0 & 0 & 0 & e^{i\theta} + \end{bmatrix} + \end{align} + + Args: + theta (Tensor): 旋转角度 + which_qubit (list): 作用在的 qubit 的编号，其值应该在 :math:`[0, n)` 范围内， :math:`n` 为该量子电路的量子比特数 + + .. code-block:: python + + import numpy as np + import paddle + from paddle_quantum.circuit import UAnsatz + theta = np.array([np.pi], np.float64) + theta = paddle.to_tensor(theta) + num_qubits = 2 + cir = UAnsatz(num_qubits) + which_qubit = [0, 1] + cir.crz(theta[0], which_qubit) + """ + assert 0 <= which_qubit[0] < self.n and 0 <= which_qubit[1] < self.n, \ + "the qubit should >= 0 and < n (the number of qubit)" + assert which_qubit[0] != which_qubit[1], \ + "the control qubit is the same as the target qubit" + curr_idx = len(self.__param) + self.__history.append({'gate': 'crz', 'which_qubits': which_qubit, 'theta': [0, 0, curr_idx]}) + self.__param.append(theta) def cnot(self, control): r"""添加一个 CNOT 门。 @@ -584,17 +1076,24 @@ class UAnsatz: 对于 2 量子比特的量子电路，当 ``control`` 为 ``[0, 1]`` 时，其矩阵形式为： .. math:: - + \begin{align} - CNOT &=|0\rangle \langle 0|\otimes I + |1 \rangle \langle 1|\otimes X\\ - &=\begin{bmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \end{bmatrix} + CNOT &=|0\rangle \langle 0|\otimes I + |1 \rangle \langle 1|\otimes X\\ + &= + \begin{bmatrix} + 1 & 0 & 0 & 0 \\ + 0 & 1 & 0 & 0 \\ + 0 & 0 & 0 & 1 \\ + 0 & 0 & 1 & 0 + \end{bmatrix} \end{align} Args: - control (list): 作用在的 qubit 的编号，``control[0]`` 为控制位，``control[1]`` 为目标位，其值都应该在 :math:`[0, n)` 范围内， :math:`n` 为该量子电路的量子比特数 + control (list): 作用在的量子比特的编号，``control[0]`` 为控制位，``control[1]`` 为目标位， + 其值都应该在 :math:`[0, n)` 范围内， :math:`n` 为该量子电路的量子比特数 .. code-block:: python - + import numpy as np import paddle from paddle_quantum.circuit import UAnsatz @@ -602,10 +1101,127 @@ class UAnsatz: cir = UAnsatz(num_qubits) cir.cnot([0, 1]) """ - assert 0 <= control[0] < self.n and 0 <= control[1] < self.n,\ + assert 0 <= control[0] < self.n and 0 <= control[1] < self.n, \ "the qubit should >= 0 and < n (the number of qubit)" - assert control[0] != control[1], "the control qubit is the same as the target qubit" - self.__history.append(['CNOT', control, None]) + assert control[0] != control[1], \ + "the control qubit is the same as the target qubit" + self.__history.append({'gate': 'CNOT', 'which_qubits': control, 'theta': None}) + + def cy(self, control): + r"""添加一个 cy 门。 + + 对于 2 量子比特的量子电路，当 ``control`` 为 ``[0, 1]`` 时，其矩阵形式为： + + .. math:: + + \begin{align} + CNOT &=|0\rangle \langle 0|\otimes I + |1 \rangle \langle 1|\otimes X\\ + &= + \begin{bmatrix} + 1 & 0 & 0 & 0 \\ + 0 & 1 & 0 & 0 \\ + 0 & 0 & 0 & -1j \\ + 0 & 0 & 1j & 0 + \end{bmatrix} + \end{align} + + Args: + control (list): 作用在的量子比特的编号，``control[0]`` 为控制位，``control[1]`` 为目标位， + 其值都应该在 :math:`[0, n)` 范围内， :math:`n` 为该量子电路的量子比特数 + + .. code-block:: python + + import numpy as np + import paddle + from paddle_quantum.circuit import UAnsatz + num_qubits = 2 + cir = UAnsatz(num_qubits) + cir.cy([0, 1]) + """ + assert 0 <= control[0] < self.n and 0 <= control[1] < self.n, \ + "the qubit should >= 0 and < n (the number of qubit)" + assert control[0] != control[1], \ + "the control qubit is the same as the target qubit" + self.__history.append({'gate': 'cy', 'which_qubits': control, 'theta': None}) + + def cz(self, control): + r"""添加一个 cz 门。 + + 对于 2 量子比特的量子电路，当 ``control`` 为 ``[0, 1]`` 时，其矩阵形式为： + + .. math:: + + \begin{align} + CNOT &=|0\rangle \langle 0|\otimes I + |1 \rangle \langle 1|\otimes X\\ + &= + \begin{bmatrix} + 1 & 0 & 0 & 0 \\ + 0 & 1 & 0 & 0 \\ + 0 & 0 & 1 & 0 \\ + 0 & 0 & 0 & -1 + \end{bmatrix} + \end{align} + + Args: + control (list): 作用在的量子比特的编号，``control[0]`` 为控制位，``control[1]`` 为目标位， + 其值都应该在 :math:`[0, n)` 范围内， :math:`n` 为该量子电路的量子比特数 + + .. code-block:: python + + import numpy as np + import paddle + from paddle_quantum.circuit import UAnsatz + num_qubits = 2 + cir = UAnsatz(num_qubits) + cir.cz([0, 1]) + """ + assert 0 <= control[0] < self.n and 0 <= control[1] < self.n, \ + "the qubit should >= 0 and < n (the number of qubit)" + assert control[0] != control[1], \ + "the control qubit is the same as the target qubit" + self.__history.append({'gate': 'cz', 'which_qubits': control, 'theta': None}) + + def cu(self, theta, phi, lam, control): + r"""添加一个控制 U 门。 + + 对于 2 量子比特的量子电路，当 ``control`` 为 ``[0, 1]`` 时，其矩阵形式为： + + .. math:: + + \begin{align} + CU + &= + \begin{bmatrix} + 1 & 0 & 0 & 0 \\ + 0 & 1 & 0 & 0 \\ + 0 & 0 & \cos\frac\theta2 &-e^{i\lambda}\sin\frac\theta2 \\ + 0 & 0 & e^{i\phi}\sin\frac\theta2&e^{i(\phi+\lambda)}\cos\frac\theta2 + \end{bmatrix} + \end{align} + + Args: + theta (Tensor): 旋转角度 :math:`\theta` 。 + phi (Tensor): 旋转角度 :math:`\phi` 。 + lam (Tensor): 旋转角度 :math:`\lambda` 。 + control (list): 作用在的量子比特的编号，``control[0]`` 为控制位，``control[1]`` 为目标位， + 其值都应该在 :math:`[0, n)` 范围内， :math:`n` 为该量子电路的量子比特数 + + .. code-block:: python + + num_qubits = 2 + cir = UAnsatz(num_qubits) + theta = paddle.to_tensor(np.array([np.pi], np.float64), stop_gradient=False) + phi = paddle.to_tensor(np.array([np.pi / 2], np.float64), stop_gradient=False) + lam = paddle.to_tensor(np.array([np.pi / 4], np.float64), stop_gradient=False) + cir.cu(theta, phi, lam, [0, 1]) + """ + assert 0 <= control[0] < self.n and 0 <= control[1] < self.n, \ + "the qubit should >= 0 and < n (the number of qubit)" + assert control[0] != control[1], \ + "the control qubit is the same as the target qubit" + curr_idx = len(self.__param) + self.__history.append({'gate': 'CU', 'which_qubits': control, 'theta': [curr_idx, curr_idx + 1, curr_idx + 2]}) + self.__param.extend([theta, phi, lam]) def swap(self, control): r"""添加一个 SWAP 门。 @@ -615,40 +1231,134 @@ class UAnsatz: .. math:: \begin{align} - SWAP = \begin{bmatrix} 1 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 1 \end{bmatrix} + SWAP = + \begin{bmatrix} + 1 & 0 & 0 & 0 \\ + 0 & 0 & 1 & 0 \\ + 0 & 1 & 0 & 0 \\ + 0 & 0 & 0 & 1 + \end{bmatrix} \end{align} Args: - control (list): 作用在的 qubit 的编号，``control[0]`` 和 ``control[1]`` 是想要交换的位，其值都应该在 :math:`[0, n)`范围内， :math:`n` 为该量子电路的量子比特数 + control (list): 作用在的量子比特的编号，``control[0]`` 和 ``control[1]`` 是想要交换的位， + 其值都应该在 :math:`[0, n)`范围内， :math:`n` 为该量子电路的量子比特数 .. code-block:: python import numpy as np - import paddle + import paddle from paddle_quantum.circuit import UAnsatz num_qubits = 2 cir = UAnsatz(num_qubits) cir.swap([0, 1]) """ - assert 0 <= control[0] < self.n and 0 <= control[1] < self.n,\ + assert 0 <= control[0] < self.n and 0 <= control[1] < self.n, \ + "the qubit should >= 0 and < n (the number of qubit)" + assert control[0] != control[1], \ + "the indices needed to be swapped should not be the same" + self.__history.append({'gate': 'SWAP', 'which_qubits': control, 'theta': None}) + + def cswap(self, control): + r"""添加一个 CSWAP (Fredkin) 门。 + + 其矩阵形式为： + + .. math:: + + \begin{align} + SWAP = + \begin{bmatrix} + 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\ + 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 \\ + 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 \\ + 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 \\ + 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 \\ + 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 \\ + 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 \\ + 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 + \end{bmatrix} + \end{align} + + Args: + control (list): 作用在的量子比特的编号，``control[0]`` 为控制位，``control[1]`` 和 ``control[2]`` 是想要交换的目标位， + 其值都应该在 :math:`[0, n)`范围内， :math:`n` 为该量子电路的量子比特数 + + .. code-block:: python + + import numpy as np + import paddle + from paddle_quantum.circuit import UAnsatz + num_qubits = 3 + cir = UAnsatz(num_qubits) + cir.cswap([0, 1, 2]) + """ + assert 0 <= control[0] < self.n and 0 <= control[1] < self.n and 0 <= control[2] < self.n, \ + "the qubit should >= 0 and < n (the number of qubit)" + assert control[0] != control[1] and control[0] != control[ + 2], "the control qubit is the same as the target qubit" + assert control[1] != control[2], "the indices needed to be swapped should not be the same" + self.__history.append({'gate': 'CSWAP', 'which_qubits': control, 'theta': None}) + + def ccx(self, control): + r"""添加一个 CCX (Toffoli) 门。 + + 其矩阵形式为： + + .. math:: + + \begin{align} + CCX = + \begin{bmatrix} + 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\ + 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 \\ + 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 \\ + 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 \\ + 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 \\ + 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 \\ + 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 \\ + 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 + \end{bmatrix} + \end{align} + + Args: + control (list): 作用在的量子比特的编号， ``control[0]`` 和 ``control[1]`` 为控制位， ``control[2]`` 为目标位， + 当控制位值都为1时在该比特位作用X门。其值都应该在 :math:`[0, n)` 范围内， :math:`n` 为该量子电路的量子比特数 + + .. code-block:: python + + import numpy as np + import paddle + from paddle_quantum.circuit import UAnsatz + num_qubits = 3 + cir = UAnsatz(num_qubits) + cir.ccx([0, 1, 2]) + """ + assert 0 <= control[0] < self.n and 0 <= control[1] < self.n and 0 <= control[2] < self.n, \ "the qubit should >= 0 and < n (the number of qubit)" - assert control[0] != control[1], "the indices needed to be swapped should not be the same" - self.__history.append(['SWAP', control, None]) + assert control[0] != control[2] and control[1] != control[2], \ + "the control qubits should not be the same as the target qubit" + assert control[0] != control[1], \ + "two control qubits should not be the same" + self.__history.append({'gate': 'CCX', 'which_qubits': control, 'theta': None}) def x(self, which_qubit): r"""添加单量子比特 X 门。 其矩阵形式为： - + .. math:: - - \begin{bmatrix} 0 & 1 \\ 1 & 0 \end{bmatrix} + + \begin{bmatrix} + 0 & 1 \\ + 1 & 0 + \end{bmatrix} Args: which_qubit (int): 作用在的qubit的编号，其值应该在 :math:`[0, n)` 范围内， :math:`n` 为该量子电路的量子比特数 .. code-block:: python - + import paddle from paddle_quantum.circuit import UAnsatz num_qubits = 1 @@ -663,22 +1373,25 @@ class UAnsatz: {'0': 0.0, '1': 1.0} """ assert 0 <= which_qubit < self.n, "the qubit should >= 0 and < n (the number of qubit)" - self.__history.append(['x', [which_qubit], None]) + self.__history.append({'gate': 'x', 'which_qubits': [which_qubit], 'theta': None}) def y(self, which_qubit): r"""添加单量子比特 Y 门。 其矩阵形式为： - + .. math:: - - \begin{bmatrix} 0 & -i \\ i & 0 \end{bmatrix} + + \begin{bmatrix} + 0 & -i \\ + i & 0 + \end{bmatrix} Args: which_qubit (int): 作用在的 qubit 的编号，其值应该在 :math:`[0, n)` 范围内， :math:`n` 为该量子电路的量子比特数 .. code-block:: python - + import paddle from paddle_quantum.circuit import UAnsatz num_qubits = 1 @@ -693,22 +1406,25 @@ class UAnsatz: {'0': 0.0, '1': 1.0} """ assert 0 <= which_qubit < self.n, "the qubit should >= 0 and < n (the number of qubit)" - self.__history.append(['y', [which_qubit], None]) + self.__history.append({'gate': 'y', 'which_qubits': [which_qubit], 'theta': None}) def z(self, which_qubit): r"""添加单量子比特 Z 门。 其矩阵形式为： - + .. math:: - - \begin{bmatrix} 1 & 0 \\ 0 & -1 \end{bmatrix} + + \begin{bmatrix} + 1 & 0 \\ + 0 & -1 + \end{bmatrix} Args: which_qubit (int): 作用在的qubit的编号，其值应该在 :math:`[0, n)` 范围内， :math:`n` 为该量子电路的量子比特数 .. code-block:: python - + import paddle from paddle_quantum.circuit import UAnsatz num_qubits = 1 @@ -723,7 +1439,7 @@ class UAnsatz: {'0': 1.0, '1': 0.0} """ assert 0 <= which_qubit < self.n, "the qubit should >= 0 and < n (the number of qubit)" - self.__history.append(['z', [which_qubit], None]) + self.__history.append({'gate': 'z', 'which_qubits': [which_qubit], 'theta': None}) def h(self, which_qubit): r"""添加一个单量子比特的 Hadamard 门。 @@ -731,14 +1447,18 @@ class UAnsatz: 其矩阵形式为： .. math:: - - H = \frac{1}{\sqrt{2}}\begin{bmatrix} 1&1\\1&-1 \end{bmatrix} + + H = \frac{1}{\sqrt{2}} + \begin{bmatrix} + 1&1\\ + 1&-1 + \end{bmatrix} Args: which_qubit (int): 作用在的 qubit 的编号，其值应该在 :math:`[0, n)` 范围内， :math:`n` 为该量子电路的量子比特数 """ assert 0 <= which_qubit < self.n, "the qubit should >= 0 and < n (the number of qubit)" - self.__history.append(['h', [which_qubit], None]) + self.__history.append({'gate': 'h', 'which_qubits': [which_qubit], 'theta': None}) def s(self, which_qubit): r"""添加一个单量子比特的 S 门。 @@ -746,16 +1466,37 @@ class UAnsatz: 其矩阵形式为： .. math:: - - S = \begin{bmatrix} 1&0\\0&i \end{bmatrix} + + S = + \begin{bmatrix} + 1&0\\ + 0&i + \end{bmatrix} Args: which_qubit (int): 作用在的 qubit 的编号，其值应该在 :math:`[0, n)` 范围内， :math:`n` 为该量子电路的量子比特数 """ assert 0 <= which_qubit < self.n, "the qubit should >= 0 and < n (the number of qubit)" - self.__history.append(['s', [which_qubit], [paddle.to_tensor(np.array([0.0])), - paddle.to_tensor(np.array([0.0])), - paddle.to_tensor(np.array([math.pi / 2]))]]) + self.__history.append({'gate': 's', 'which_qubits': [which_qubit], 'theta': [0, 0, 1]}) + + def sdg(self, which_qubit): + r"""添加一个单量子比特的 S dagger 门。 + + 其矩阵形式为： + + .. math:: + + S^\dagger = + \begin{bmatrix} + 1&0\\ + 0&-i + \end{bmatrix} + + Args: + which_qubit (int): 作用在的 qubit 的编号，其值应该在 :math:`[0, n)` 范围内， :math:`n` 为该量子电路的量子比特数 + """ + assert 0 <= which_qubit < self.n, "the qubit should >= 0 and < n (the number of qubit)" + self.__history.append({'gate': 'sdg', 'which_qubits': [which_qubit], 'theta': [0, 0, 2]}) def t(self, which_qubit): r"""添加一个单量子比特的 T 门。 @@ -764,15 +1505,36 @@ class UAnsatz: .. math:: - T = \begin{bmatrix} 1&0\\0&e^\frac{i\pi}{4} \end{bmatrix} + T = + \begin{bmatrix} + 1&0\\ + 0&e^\frac{i\pi}{4} + \end{bmatrix} Args: which_qubit (int): 作用在的 qubit 的编号，其值应该在 :math:`[0, n)` 范围内， :math:`n` 为该量子电路的量子比特数 """ assert 0 <= which_qubit < self.n, "the qubit should >= 0 and < n (the number of qubit)" - self.__history.append(['t', [which_qubit], [paddle.to_tensor(np.array([0.0])), - paddle.to_tensor(np.array([0.0])), - paddle.to_tensor(np.array([math.pi / 4]))]]) + self.__history.append({'gate': 't', 'which_qubits': [which_qubit], 'theta': [0, 0, 3]}) + + def tdg(self, which_qubit): + r"""添加一个单量子比特的 T dagger 门。 + + 其矩阵形式为： + + .. math:: + + T^\dagger = + \begin{bmatrix} + 1&0\\ + 0&e^\frac{-i\pi}{4} + \end{bmatrix} + + Args: + which_qubit (int): 作用在的 qubit 的编号，其值应该在 :math:`[0, n)` 范围内， :math:`n` 为该量子电路的量子比特数 + """ + assert 0 <= which_qubit < self.n, "the qubit should >= 0 and < n (the number of qubit)" + self.__history.append({'gate': 'tdg', 'which_qubits': [which_qubit], 'theta': [0, 0, 4]}) def u3(self, theta, phi, lam, which_qubit): r"""添加一个单量子比特的旋转门。 @@ -780,13 +1542,13 @@ class UAnsatz: 其矩阵形式为： .. math:: - + \begin{align} - U3(\theta, \phi, \lambda) = - \begin{bmatrix} - \cos\frac\theta2&-e^{i\lambda}\sin\frac\theta2\\ - e^{i\phi}\sin\frac\theta2&e^{i(\phi+\lambda)}\cos\frac\theta2 - \end{bmatrix} + U3(\theta, \phi, \lambda) = + \begin{bmatrix} + \cos\frac\theta2&-e^{i\lambda}\sin\frac\theta2\\ + e^{i\phi}\sin\frac\theta2&e^{i(\phi+\lambda)}\cos\frac\theta2 + \end{bmatrix} \end{align} Args: @@ -796,7 +1558,10 @@ class UAnsatz: which_qubit (int): 作用在的 qubit 的编号，其值应该在 :math:`[0, n)` 范围内， :math:`n` 为该量子电路的量子比特数 """ assert 0 <= which_qubit < self.n, "the qubit should >= 0 and < n (the number of qubit)" - self.__history.append(['u', [which_qubit], [theta, phi, lam]]) + curr_idx = len(self.__param) + self.__history.append( + {'gate': 'u', 'which_qubits': [which_qubit], 'theta': [curr_idx, curr_idx + 1, curr_idx + 2]}) + self.__param.extend([theta, phi, lam]) def rxx(self, theta, which_qubits): r"""添加一个 RXX 门。 @@ -806,13 +1571,13 @@ class UAnsatz: .. math:: \begin{align} - RXX(\theta) = - \begin{bmatrix} - \cos\frac{\theta}{2} & 0 & 0 & -i\sin\frac{\theta}{2} \\ - 0 & \cos\frac{\theta}{2} & -i\sin\frac{\theta}{2} & 0 \\ - 0 & -i\sin\frac{\theta}{2} & \cos\frac{\theta}{2} & 0 \\ - -i\sin\frac{\theta}{2} & 0 & 0 & \cos\frac{\theta}{2} - \end{bmatrix} + RXX(\theta) = + \begin{bmatrix} + \cos\frac{\theta}{2} & 0 & 0 & -i\sin\frac{\theta}{2} \\ + 0 & \cos\frac{\theta}{2} & -i\sin\frac{\theta}{2} & 0 \\ + 0 & -i\sin\frac{\theta}{2} & \cos\frac{\theta}{2} & 0 \\ + -i\sin\frac{\theta}{2} & 0 & 0 & \cos\frac{\theta}{2} + \end{bmatrix} \end{align} Args: @@ -831,7 +1596,9 @@ class UAnsatz: assert 0 <= which_qubits[0] < self.n and 0 <= which_qubits[1] < self.n, \ "the qubit should >= 0 and < n (the number of qubit)" assert which_qubits[0] != which_qubits[1], "the indices of two qubits should be different" - self.__history.append(['RXX_gate', which_qubits, theta]) + curr_idx = len(self.__param) + self.__history.append({'gate': 'RXX_gate', 'which_qubits': which_qubits, 'theta': [curr_idx]}) + self.__param.append(theta) def ryy(self, theta, which_qubits): r"""添加一个 RYY 门。 @@ -841,13 +1608,13 @@ class UAnsatz: .. math:: \begin{align} - RYY(\theta) = - \begin{bmatrix} - \cos\frac{\theta}{2} & 0 & 0 & i\sin\frac{\theta}{2} \\ - 0 & \cos\frac{\theta}{2} & -i\sin\frac{\theta}{2} & 0 \\ - 0 & -i\sin\frac{\theta}{2} & \cos\frac{\theta}{2} & 0 \\ - i\sin\frac{\theta}{2} & 0 & 0 & cos\frac{\theta}{2} - \end{bmatrix} + RYY(\theta) = + \begin{bmatrix} + \cos\frac{\theta}{2} & 0 & 0 & i\sin\frac{\theta}{2} \\ + 0 & \cos\frac{\theta}{2} & -i\sin\frac{\theta}{2} & 0 \\ + 0 & -i\sin\frac{\theta}{2} & \cos\frac{\theta}{2} & 0 \\ + i\sin\frac{\theta}{2} & 0 & 0 & cos\frac{\theta}{2} + \end{bmatrix} \end{align} Args: @@ -866,7 +1633,9 @@ class UAnsatz: assert 0 <= which_qubits[0] < self.n and 0 <= which_qubits[1] < self.n, \ "the qubit should >= 0 and < n (the number of qubit)" assert which_qubits[0] != which_qubits[1], "the indices of two qubits should be different" - self.__history.append(['RYY_gate', which_qubits, theta]) + curr_idx = len(self.__param) + self.__history.append({'gate': 'RYY_gate', 'which_qubits': which_qubits, 'theta': [curr_idx]}) + self.__param.append(theta) def rzz(self, theta, which_qubits): r"""添加一个 RZZ 门。 @@ -876,13 +1645,13 @@ class UAnsatz: .. math:: \begin{align} - RZZ(\theta) = - \begin{bmatrix} - e^{-i\frac{\theta}{2}} & 0 & 0 & 0 \\ - 0 & e^{i\frac{\theta}{2}} & 0 & 0 \\ - 0 & 0 & e^{i\frac{\theta}{2}} & 0 \\ - 0 & 0 & 0 & e^{-i\frac{\theta}{2}} - \end{bmatrix} + RZZ(\theta) = + \begin{bmatrix} + e^{-i\frac{\theta}{2}} & 0 & 0 & 0 \\ + 0 & e^{i\frac{\theta}{2}} & 0 & 0 \\ + 0 & 0 & e^{i\frac{\theta}{2}} & 0 \\ + 0 & 0 & 0 & e^{-i\frac{\theta}{2}} + \end{bmatrix} \end{align} Args: @@ -901,7 +1670,9 @@ class UAnsatz: assert 0 <= which_qubits[0] < self.n and 0 <= which_qubits[1] < self.n, \ "the qubit should >= 0 and < n (the number of qubit)" assert which_qubits[0] != which_qubits[1], "the indices of two qubits should be different" - self.__history.append(['RZZ_gate', which_qubits, theta]) + curr_idx = len(self.__param) + self.__history.append({'gate': 'RZZ_gate', 'which_qubits': which_qubits, 'theta': [curr_idx]}) + self.__param.append(theta) def ms(self, which_qubits): r"""添加一个 Mølmer-Sørensen (MS) 门，用于离子阱设备。 @@ -911,13 +1682,13 @@ class UAnsatz: .. math:: \begin{align} - MS = RXX(-\frac{\pi}{2}) = \frac{1}{\sqrt{2}} - \begin{bmatrix} - 1 & 0 & 0 & i \\ - 0 & 1 & i & 0 \\ - 0 & i & 1 & 0 \\ - i & 0 & 0 & 1 - \end{bmatrix} + MS = RXX(-\frac{\pi}{2}) = \frac{1}{\sqrt{2}} + \begin{bmatrix} + 1 & 0 & 0 & i \\ + 0 & 1 & i & 0 \\ + 0 & i & 1 & 0 \\ + i & 0 & 0 & 1 + \end{bmatrix} \end{align} Args: @@ -938,7 +1709,7 @@ class UAnsatz: assert 0 <= which_qubits[0] < self.n and 0 <= which_qubits[1] < self.n, \ "the qubit should >= 0 and < n(the number of qubit)" assert which_qubits[0] != which_qubits[1], "the indices of two qubits should be different" - self.__history.append(['MS_gate', which_qubits, paddle.to_tensor(-np.array([np.pi / 2]))]) + self.__history.append({'gate': 'MS_gate', 'which_qubits': which_qubits, 'theta': [2]}) def universal_2_qubit_gate(self, theta, which_qubits): r"""添加 2-qubit 通用门，这个通用门需要 15 个参数。 @@ -965,13 +1736,13 @@ class UAnsatz: {'00': 0.4306256106527819, '01': 0.07994547866706268, '10': 0.07994547866706264, '11': 0.40948343201309334} """ - + assert len(theta.shape) == 1, 'The shape of theta is not right' assert len(theta) == 15, 'This Ansatz accepts 15 parameters' assert len(which_qubits) == 2, "You should add this gate on two qubits" a, b = which_qubits - + self.u3(theta[0], theta[1], theta[2], a) self.u3(theta[3], theta[4], theta[5], b) self.cnot([b, a]) @@ -1021,15 +1792,253 @@ class UAnsatz: self.rz(theta[2], which_qubits[2]) self.cnot([which_qubits[0], which_qubits[2]]) - def universal_3_qubit_gate(self, theta, which_qubits): - r"""添加 3-qubit 通用门，这个通用门需要 81 个参数。 + def universal_3_qubit_gate(self, theta, which_qubits): + r"""添加 3-qubit 通用门，这个通用门需要 81 个参数。 + + Args: + theta (Tensor): 3-qubit 通用门的参数，其维度为 ``(81, )`` + which_qubits(list): 作用的量子比特编号 + + Note: + 参考: https://cds.cern.ch/record/708846/files/0401178.pdf + + 代码示例: + + .. code-block:: python + + import numpy as np + import paddle + from paddle_quantum.circuit import UAnsatz + n = 3 + theta = paddle.to_tensor(np.ones(81)) + cir = UAnsatz(n) + cir.universal_3_qubit_gate(theta, [0, 1, 2]) + cir.run_state_vector() + print(cir.measure(shots = 0)) + + :: + + {'000': 0.06697926831547105, '001': 0.13206788591381013, '010': 0.2806525391078656, '011': 0.13821526515701105, '100': 0.1390530116439897, '101': 0.004381404333075108, '110': 0.18403296778911565, '111': 0.05461765773966483} + """ + assert len(which_qubits) == 3, "You should add this gate on three qubits" + assert len(theta) == 81, "The length of theta is supposed to be 81" + + psi = reshape(x=theta[: 60], shape=[4, 15]) + phi = reshape(x=theta[60:], shape=[7, 3]) + self.universal_2_qubit_gate(psi[0], which_qubits[:2]) + self.u3(phi[0][0], phi[0][1], phi[0][2], which_qubits[2]) + + self.__u3qg_U(phi[1], which_qubits) + + self.universal_2_qubit_gate(psi[1], which_qubits[:2]) + self.u3(phi[2][0], phi[2][1], phi[2][2], which_qubits[2]) + + self.__u3qg_V(phi[3], which_qubits) + + self.universal_2_qubit_gate(psi[2], which_qubits[:2]) + self.u3(phi[4][0], phi[4][1], phi[4][2], which_qubits[2]) + + self.__u3qg_U(phi[5], which_qubits) + + self.universal_2_qubit_gate(psi[3], which_qubits[:2]) + self.u3(phi[6][0], phi[6][1], phi[6][2], which_qubits[2]) + + def pauli_rotation_gate_partial(self, ind, gate_name): + r"""计算传入的泡利旋转门的偏导。 + + Args: + ind (int): 该门在本电路中的序号 + gate_name (string): 门的名字 + + Return: + UAnsatz: 用电路表示的该门的偏导 + + 代码示例: + + .. code-block:: python + + import numpy as np + import paddle + from paddle_quantum.circuit import UAnsatz + cir = UAnsatz(2) + theta = paddle.to_tensor([np.pi, np.pi/2, np.pi/4], 'float64') + cir.rx(theta[0], 0) + cir.ryy(theta[1], [1, 0]) + cir.rz(theta[2], 1) + print(cir.pauli_rotation_gate_partial(0, 'rx')) + + :: + + ------------x----Rx(3.142)----Ryy(1.57)--------------- + | | + ------------|-----------------Ryy(1.57)----Rz(0.785)-- + | + --H---SDG---*--------H-------------------------------- + """ + history, param = self._get_history() + assert ind <= len(history), "The index number should be less than or equal to %d" % len(history) + assert gate_name in {'rx', 'ry', 'rz', 'RXX_gate', 'RYY_gate', 'RZZ_gate'}, "Gate not supported." + assert gate_name == history[ind]['gate'], "Gate name incorrect." + + n = self.n + new_circuit = UAnsatz(n + 1) + new_circuit._add_history(history[:ind], param) + new_circuit.h(n) + new_circuit.sdg(n) + if gate_name in {'rx', 'RXX_gate'}: + new_circuit.cnot([n, history[ind]['which_qubits'][0]]) + if gate_name == 'RXX_gate': + new_circuit.cnot([n, history[ind]['which_qubits'][1]]) + elif gate_name in {'ry', 'RYY_gate'}: + new_circuit.cy([n, history[ind]['which_qubits'][0]]) + if gate_name == 'RYY_gate': + new_circuit.cy([n, history[ind]['which_qubits'][1]]) + elif gate_name in {'rz', 'RZZ_gate'}: + new_circuit.cz([n, history[ind]['which_qubits'][0]]) + if gate_name == 'RZZ_gate': + new_circuit.cz([n, history[ind]['which_qubits'][1]]) + new_circuit.h(n) + new_circuit._add_history(history[ind: len(history)], param) + + return new_circuit + + def control_rotation_gate_partial(self, ind, gate_name): + r"""计算传入的控制旋转门的偏导。 + + Args: + ind (int): 该门在本电路中的序号 + gate_name (string): 门的名字 + + Return: + List: 用两个电路表示的该门的偏导 + + 代码示例: + + .. code-block:: python + + import numpy as np + import paddle + from paddle_quantum.circuit import UAnsatz + cir = UAnsatz(2) + theta = paddle.to_tensor([np.pi, np.pi/2, np.pi/4], 'float64') + cir.rx(theta[0], 0) + cir.ryy(theta[1], [1, 0]) + cir.crz(theta[2], [0, 1]) + print(cir.control_rotation_gate_partial(2, 'crz')[0]) + print(cir.control_rotation_gate_partial(2, 'crz')[1]) + + :: + + --Rx(3.142)----Ryy(1.57)-------------*------ + | | + ---------------Ryy(1.57)----z----Rz(0.785)-- + | + ------H-----------SDG-------*--------H------ + + --Rx(3.142)----Ryy(1.57)----z-------------*------ + | | | + ---------------Ryy(1.57)----|----z----Rz(0.785)-- + | | + ------H------------S--------*----*--------H------ + """ + history, param = self._get_history() + assert ind <= len(history), "The index number should be less than or equal to %d" % len(history) + assert gate_name in {'crx', 'cry', 'crz'}, "Gate not supported." + assert gate_name == history[ind]['gate'], "Gate name incorrect." + + n = self.n + new_circuit = [UAnsatz(n + 1) for j in range(2)] + for k in range(2): + new_circuit[k]._add_history(history[:ind], param) + new_circuit[k].h(n) + new_circuit[k].sdg(n) if k == 0 else new_circuit[k].s(n) + if k == 1: + new_circuit[k].cz([n, history[ind]['which_qubits'][1]]) + if gate_name == 'crx': + new_circuit[k].cnot([n, history[ind]['which_qubits'][0]]) + elif gate_name == 'cry': + new_circuit[k].cy([n, history[ind]['which_qubits'][0]]) + elif gate_name == 'crz': + new_circuit[k].cz([n, history[ind]['which_qubits'][0]]) + new_circuit[k].h(n) + new_circuit[k]._add_history(history[ind: len(history)], param) + + return new_circuit + + def u3_partial(self, ind_history, ind_gate): + r"""计算传入的 u3 门的一个参数的偏导。 + + Args: + ind_history (int): 该门在本电路中的序号 + ind_gate (int): u3 门参数的 index，可以是 0 或 1 或 2 + + Return: + UAnsatz: 用电路表示的该门的一个参数的偏导 - Note: - 参考: https://cds.cern.ch/record/708846/files/0401178.pdf + 代码示例: + + .. code-block:: python + + import numpy as np + import paddle + from paddle_quantum.circuit import UAnsatz + cir = UAnsatz(2) + theta = paddle.to_tensor([np.pi, np.pi/2, np.pi/4], 'float64') + cir.u3(theta[0], theta[1], theta[2], 0) + print(cir.u3_partial(0, 0)) + + :: + + ------------z----U-- + | + ------------|------- + | + --H---SDG---*----H-- + """ + history, param = self._get_history() + assert ind_history <= len(history), "The index number should be less than or equal to %d" % len(history) + assert ind_gate in {0, 1, 2}, "U3 gate has only three parameters, please choose from {0, 1, 2}" + assert history[ind_history]['gate'] == 'u', "Not a u3 gate." + + n = self.n + new_circuit = UAnsatz(n + 1) + assert ind_gate in {0, 1, 2}, "ind must be in {0, 1, 2}" + new_circuit._add_history(history[:ind_history], param) + if ind_gate == 0: + new_circuit.h(n) + new_circuit.sdg(n) + new_circuit.cz([n, history[ind_history]['which_qubits'][0]]) + new_circuit.h(n) + new_circuit._add_history(history[ind_history], param) + elif ind_gate == 1: + new_circuit.h(n) + new_circuit.sdg(n) + new_circuit.rz(self.__param[history[ind_history]['theta'][2]], history[ind_history]['which_qubits'][0]) + new_circuit.cy([n, history[ind_history]['which_qubits'][0]]) + new_circuit.ry(self.__param[history[ind_history]['theta'][0]], history[ind_history]['which_qubits'][0]) + new_circuit.rz(self.__param[history[ind_history]['theta'][1]], history[ind_history]['which_qubits'][0]) + new_circuit.h(n) + elif ind_gate == 2: + new_circuit.h(n) + new_circuit.sdg(n) + new_circuit.rz(self.__param[history[ind_history]['theta'][2]], history[ind_history]['which_qubits'][0]) + new_circuit.ry(self.__param[history[ind_history]['theta'][0]], history[ind_history]['which_qubits'][0]) + new_circuit.cz([n, history[ind_history]['which_qubits'][0]]) + new_circuit.rz(self.__param[history[ind_history]['theta'][1]], history[ind_history]['which_qubits'][0]) + new_circuit.h(n) + new_circuit._add_history(history[ind_history + 1: len(history)], param) + + return new_circuit + + def cu3_partial(self, ind_history, ind_gate): + r"""计算传入的 cu 门的一个参数的偏导。 Args: - theta (Tensor): 3-qubit 通用门的参数，其维度为 ``(81, )`` - which_qubits(list): 作用的量子比特编号 + ind_history (int): 该门在本电路中的序号 + ind_gate (int): cu 门参数的 index，可以是 0 或 1 或 2 + + Return: + UAnsatz: 用电路表示的该门的一个参数的偏导 代码示例: @@ -1038,46 +2047,246 @@ class UAnsatz: import numpy as np import paddle from paddle_quantum.circuit import UAnsatz - n = 3 - theta = paddle.to_tensor(np.ones(81)) - cir = UAnsatz(n) - cir.universal_3_qubit_gate(theta, [0, 1, 2]) - cir.run_state_vector() - print(cir.measure(shots = 0)) + cir = UAnsatz(2) + theta = paddle.to_tensor([np.pi, np.pi/2, np.pi/4], 'float64') + cir.cu(theta[0], theta[1], theta[2], [0, 1]) + print(cir.cu3_partial(0, 0)[0]) + print(cir.cu3_partial(0, 0)[1]) :: - {'000': 0.06697926831547105, '001': 0.13206788591381013, '010': 0.2806525391078656, '011': 0.13821526515701105, '100': 0.1390530116439897, '101': 0.004381404333075108, '110': 0.18403296778911565, '111': 0.05461765773966483} + -----------------x-- + | + ------------z----U-- + | + --H---SDG---*----H-- + + ------------z---------x-- + | | + ------------|----z----U-- + | | + --H----S----*----*----H-- """ - assert len(which_qubits) == 3, "You should add this gate on three qubits" - assert len(theta) == 81, "The length of theta is supposed to be 81" + history, param = self._get_history() + assert ind_history <= len(history), "The index number should be less than or equal to %d" % len(history) + assert ind_gate in {0, 1, 2}, "CU gate has only three parameters, please choose from {0, 1, 2}" + assert history[ind_history]['gate'] == 'CU', "Not a CU gate." - psi = reshape(x=theta[: 60], shape=[4, 15]) - phi = reshape(x=theta[60:], shape=[7, 3]) - self.universal_2_qubit_gate(psi[0], which_qubits[:2]) - self.u3(phi[0][0], phi[0][1], phi[0][2], which_qubits[2]) + n = self.n + new_circuit = [UAnsatz(n + 1) for j in range(2)] + assert ind_gate in {0, 1, 2}, "ind must be in {0, 1, 2}" + for k in range(2): + new_circuit[k]._add_history(history[:ind_history], param) + if ind_gate == 0: + new_circuit[k].h(n) + new_circuit[k].sdg(n) if k == 0 else new_circuit[k].s(n) + if k == 1: + new_circuit[k].cz([n, history[ind_history]['which_qubits'][0]]) + new_circuit[k].cz([n, history[ind_history]['which_qubits'][1]]) + new_circuit[k].h(n) + new_circuit[k]._add_history([history[ind_history]], param) + elif ind_gate == 1: + new_circuit[k].h(n) + new_circuit[k].sdg(n) if k == 0 else new_circuit[k].s(n) + new_circuit[k].crz(self.__param[history[ind_history]['theta'][2]], history[ind_history]['which_qubits']) + if k == 1: + new_circuit[k].cz([n, history[ind_history]['which_qubits'][0]]) + new_circuit[k].cy([n, history[ind_history]['which_qubits'][0]]) + new_circuit[k].cry(self.__param[history[ind_history]['theta'][0]], history[ind_history]['which_qubits']) + new_circuit[k].crz(self.__param[history[ind_history]['theta'][1]], history[ind_history]['which_qubits']) + new_circuit[k].h(n) + elif ind_gate == 2: + new_circuit[k].h(n) + new_circuit[k].sdg(n) if k == 0 else new_circuit[k].s(n) + new_circuit[k].crz(self.__param[history[ind_history]['theta'][2]], history[ind_history]['which_qubits']) + new_circuit[k].cry(self.__param[history[ind_history]['theta'][0]], history[ind_history]['which_qubits']) + if k == 1: + new_circuit[k].cz([n, history[ind_history]['which_qubits'][0]]) + new_circuit[k].cz([n, history[ind_history]['which_qubits'][0]]) + new_circuit[k].crz(self.__param[history[ind_history]['theta'][1]], history[ind_history]['which_qubits']) + new_circuit[k].h(n) + + new_circuit[k]._add_history(history[ind_history + 1: len(history)], param) + + return new_circuit + + def linear_combinations_gradient(self, H, shots=0): + r"""用 linear combination 的方法计算电路中所有需要训练的参数的梯度。损失函数默认为计算哈密顿量的期望值。 - self.__u3qg_U(phi[1], which_qubits) + Args: + H (list or Hamiltonian): 损失函数中用到的记录哈密顿量信息的列表或 ``Hamiltonian`` 类的对象 + shots (int, optional): 测量次数；默认为 0，表示返回期望值的精确值，即测量无穷次后的期望值 - self.universal_2_qubit_gate(psi[1], which_qubits[:2]) - self.u3(phi[2][0], phi[2][1], phi[2][2], which_qubits[2]) + Return: + Tensor: 该电路中所有需要训练的参数的梯度 - self.__u3qg_V(phi[3], which_qubits) + 代码示例: - self.universal_2_qubit_gate(psi[2], which_qubits[:2]) - self.u3(phi[4][0], phi[4][1], phi[4][2], which_qubits[2]) + .. code-block:: python - self.__u3qg_U(phi[5], which_qubits) + import numpy as np + import paddle + from paddle_quantum.circuit import UAnsatz - self.universal_2_qubit_gate(psi[3], which_qubits[:2]) - self.u3(phi[6][0], phi[6][1], phi[6][2], which_qubits[2]) + def U_theta(theta, N, D): + cir = UAnsatz(N) + cir.complex_entangled_layer(theta[:D], D) + for i in range(N): + cir.ry(theta=theta[D][i][0], which_qubit=i) + cir.run_state_vector() + return cir + + H = [[1.0, 'z0,z1']] + theta = paddle.uniform(shape=[2, 2, 3], dtype='float64', min=0.0, max=np.pi * 2) + theta.stop_gradient = False + circuit = U_theta(theta, 2, 1) + gradient = circuit.linear_combinations_gradient(H, shots=0) + print(gradient) + + :: + + Tensor(shape=[8], dtype=float64, place=CPUPlace, stop_gradient=True, + [ 0. , -0.11321444, -0.22238044, 0. , 0.04151700, 0.44496212, -0.19465690, 0.96022600]) + """ + history, param = self._get_history() + grad = [] + + if not isinstance(H, list): + H = H.pauli_str + H = copy.deepcopy(H) + for i in H: + i[1] += ',z' + str(self.n) + + for i, history_i in enumerate(history): + if history_i['gate'] == 'rx' and self.__param[history_i['theta'][0]].stop_gradient is False: + new_circuit = self.pauli_rotation_gate_partial(i, 'rx') + if self.__run_mode == 'state_vector': + new_circuit.run_state_vector() + elif self.__run_mode == 'density_matrix': + new_circuit.run_density_matrix() + grad.append(paddle.to_tensor(new_circuit.expecval(H, shots), 'float64')) + elif history_i['gate'] == 'ry' and self.__param[history_i['theta'][0]].stop_gradient is False: + new_circuit = self.pauli_rotation_gate_partial(i, 'ry') + if self.__run_mode == 'state_vector': + new_circuit.run_state_vector() + elif self.__run_mode == 'density_matrix': + new_circuit.run_density_matrix() + grad.append(paddle.to_tensor(new_circuit.expecval(H, shots), 'float64')) + elif history_i['gate'] == 'rz' and self.__param[history_i['theta'][2]].stop_gradient is False: + new_circuit = self.pauli_rotation_gate_partial(i, 'rz') + if self.__run_mode == 'state_vector': + new_circuit.run_state_vector() + elif self.__run_mode == 'density_matrix': + new_circuit.run_density_matrix() + grad.append(paddle.to_tensor(new_circuit.expecval(H, shots), 'float64')) + elif history_i['gate'] == 'crx' and self.__param[history_i['theta'][0]].stop_gradient is False: + new_circuit = self.control_rotation_gate_partial(i, 'crx') + for k in new_circuit: + if self.__run_mode == 'state_vector': + k.run_state_vector() + elif self.__run_mode == 'density_matrix': + k.run_density_matrix() + gradient = paddle.to_tensor(np.mean([circuit.expecval(H, shots) for circuit in new_circuit]), 'float64') + grad.append(gradient) + elif history_i['gate'] == 'cry' and self.__param[history_i['theta'][0]].stop_gradient is False: + new_circuit = self.control_rotation_gate_partial(i, 'cry') + for k in new_circuit: + if self.__run_mode == 'state_vector': + k.run_state_vector() + elif self.__run_mode == 'density_matrix': + k.run_density_matrix() + gradient = paddle.to_tensor(np.mean([circuit.expecval(H, shots) for circuit in new_circuit]), 'float64') + grad.append(gradient) + elif history_i['gate'] == 'crz' and self.__param[history_i['theta'][2]].stop_gradient is False: + new_circuit = self.control_rotation_gate_partial(i, 'crz') + for k in new_circuit: + if self.__run_mode == 'state_vector': + k.run_state_vector() + elif self.__run_mode == 'density_matrix': + k.run_density_matrix() + gradient = paddle.to_tensor(np.mean([circuit.expecval(H, shots) for circuit in new_circuit]), 'float64') + grad.append(gradient) + elif history_i['gate'] == 'RXX_gate' and self.__param[history_i['theta'][0]].stop_gradient is False: + new_circuit = self.pauli_rotation_gate_partial(i, 'RXX_gate') + if self.__run_mode == 'state_vector': + new_circuit.run_state_vector() + elif self.__run_mode == 'density_matrix': + new_circuit.run_density_matrix() + grad.append(paddle.to_tensor(new_circuit.expecval(H, shots), 'float64')) + elif history_i['gate'] == 'RYY_gate' and self.__param[history_i['theta'][0]].stop_gradient is False: + new_circuit = self.pauli_rotation_gate_partial(i, 'RYY_gate') + if self.__run_mode == 'state_vector': + new_circuit.run_state_vector() + elif self.__run_mode == 'density_matrix': + new_circuit.run_density_matrix() + grad.append(paddle.to_tensor(new_circuit.expecval(H, shots), 'float64')) + elif history_i['gate'] == 'RZZ_gate' and self.__param[history_i['theta'][0]].stop_gradient is False: + new_circuit = self.pauli_rotation_gate_partial(i, 'RZZ_gate') + if self.__run_mode == 'state_vector': + new_circuit.run_state_vector() + elif self.__run_mode == 'density_matrix': + new_circuit.run_density_matrix() + grad.append(paddle.to_tensor(new_circuit.expecval(H, shots), 'float64')) + elif history_i['gate'] == 'u': + if not self.__param[history_i['theta'][0]].stop_gradient: + new_circuit = self.u3_partial(i, 0) + if self.__run_mode == 'state_vector': + new_circuit.run_state_vector() + elif self.__run_mode == 'density_matrix': + new_circuit.run_density_matrix() + grad.append(paddle.to_tensor(new_circuit.expecval(H, shots), 'float64')) + if not self.__param[history_i['theta'][1]].stop_gradient: + new_circuit = self.u3_partial(i, 1) + if self.__run_mode == 'state_vector': + new_circuit.run_state_vector() + elif self.__run_mode == 'density_matrix': + new_circuit.run_density_matrix() + grad.append(paddle.to_tensor(new_circuit.expecval(H, shots), 'float64')) + if not self.__param[history_i['theta'][2]].stop_gradient: + new_circuit = self.u3_partial(i, 2) + if self.__run_mode == 'state_vector': + new_circuit.run_state_vector() + elif self.__run_mode == 'density_matrix': + new_circuit.run_density_matrix() + grad.append(paddle.to_tensor(new_circuit.expecval(H, shots), 'float64')) + elif history_i['gate'] == 'CU': + if not self.__param[history_i['theta'][0]].stop_gradient: + new_circuit = self.cu3_partial(i, 0) + for k in new_circuit: + if self.__run_mode == 'state_vector': + k.run_state_vector() + elif self.__run_mode == 'density_matrix': + k.run_density_matrix() + gradient = paddle.to_tensor(np.mean([circuit.expecval(H, shots) for circuit in new_circuit]), 'float64') + grad.append(gradient) + if not self.__param[history_i['theta'][1]].stop_gradient: + new_circuit = self.cu3_partial(i, 1) + for k in new_circuit: + if self.__run_mode == 'state_vector': + k.run_state_vector() + elif self.__run_mode == 'density_matrix': + k.run_density_matrix() + gradient = paddle.to_tensor(np.mean([circuit.expecval(H, shots) for circuit in new_circuit]), 'float64') + grad.append(gradient) + if not self.__param[history_i['theta'][2]].stop_gradient: + new_circuit = self.cu3_partial(i, 2) + for k in new_circuit: + if self.__run_mode == 'state_vector': + k.run_state_vector() + elif self.__run_mode == 'density_matrix': + k.run_density_matrix() + gradient = paddle.to_tensor(np.mean([circuit.expecval(H, shots) for circuit in new_circuit]), 'float64') + grad.append(gradient) + grad = paddle.concat(grad) + + return grad """ Measurements """ def __process_string(self, s, which_qubits): - r""" + r"""该函数基于 which_qubits 返回 s 的一部分 This functions return part of string s baesd on which_qubits If s = 'abcdefg', which_qubits = [0,2,5], then it returns 'acf' @@ -1088,9 +2297,10 @@ class UAnsatz: return new_s def __process_similiar(self, result): - r""" + r"""该函数基于相同的键合并值。 This functions merges values based on identical keys. - If result = [('00', 10), ('01', 20), ('11', 30), ('11', 40), ('11', 50), ('00', 60)], then it returns {'00': 70, '01': 20, '11': 120} + If result = [('00', 10), ('01', 20), ('11', 30), ('11', 40), ('11', 50), ('00', 60)], + then it returns {'00': 70, '01': 20, '11': 120} Note: 这是内部函数，你并不需要直接调用到该函数。 @@ -1148,14 +2358,14 @@ class UAnsatz: which_qubits (list, optional): 要测量的qubit的编号，默认全都测量 shots (int, optional): 该量子电路输出的量子态的测量次数，默认为 1024 次；若为 0，则返回测量结果的精确概率分布 plot (bool, optional): 是否绘制测量结果图，默认为 ``False`` ，即不绘制 - + Returns: dict: 测量的结果 代码示例: .. code-block:: python - + import paddle from paddle_quantum.circuit import UAnsatz cir = UAnsatz(2) @@ -1184,9 +2394,9 @@ class UAnsatz: The probability distribution of measurement results on qubit 1 is {'0': 0.4999999999999999, '1': 0.4999999999999999} """ - if self.__run_state == 'state_vector': + if self.__run_mode == 'state_vector': state = self.__state - elif self.__run_state == 'density_matrix': + elif self.__run_mode == 'density_matrix': # Take the diagonal of the density matrix as a probability distribution diag = np.diag(self.__state.numpy()) state = paddle.to_tensor(np.sqrt(diag)) @@ -1217,47 +2427,120 @@ class UAnsatz: return result if not plot else self.__measure_hist(result, which_qubits, shots) - def expecval(self, H): + def measure_in_bell_basis(self, which_qubits, shots=0): + r"""对量子电路输出的量子态进行贝尔基测量。 + + Args: + which_qubits(list): 要测量的量子比特 + shots(int): 测量的采样次数，默认为0，表示计算解析解 + + Returns: + list: 测量得到四个贝尔基的概率 + """ + assert which_qubits[0] != which_qubits[1], "You have to measure two different qubits." + which_qubits.sort() + i, j = which_qubits + qubit_num = self.n + input_state = self.__state + mode = self.__run_mode + cir = UAnsatz(qubit_num) + cir.cnot([i, j]) + cir.h(i) + + if mode == 'state_vector': + output_state = cir.run_state_vector(input_state).numpy() + elif mode == 'density_matrix': + output_density_matrix = cir.run_density_matrix(input_state).numpy() + output_state = np.sqrt(np.diag(output_density_matrix)) + else: + raise ValueError("Can't recognize the mode of quantum state.") + + prob_amplitude = np.abs(output_state).tolist() + prob_amplitude = [item ** 2 for item in prob_amplitude] + + prob_array = [0] * 4 + for i in range(2 ** qubit_num): + binary = bin(i)[2:] + binary = '0' * (qubit_num - len(binary)) + binary + target_qubits = str() + for qubit_idx in which_qubits: + target_qubits += binary[qubit_idx] + prob_array[int(target_qubits, base=2)] += prob_amplitude[i] + + if shots == 0: + result = prob_array + else: + result = [0] * 4 + samples = np.random.choice(list(range(4)), shots, p=prob_array) + for item in samples: + result[item] += 1 + result = [item / shots for item in result] + + return result + + def expecval(self, H, shots=0): r"""量子电路输出的量子态关于可观测量 H 的期望值。 Hint: - 如果想输入的可观测量的矩阵为 :math:`0.7Z\otimes X\otimes I+0.2I\otimes Z\otimes I` 。则 ``H`` 应为 ``[[0.7, 'z0,x1'], [0.2, 'z1']]`` 。 + 如果想输入的可观测量的矩阵为 :math:`0.7Z\otimes X\otimes I+0.2I\otimes Z\otimes I` ， + 则 ``H`` 的 ``list`` 形式为 ``[[0.7, 'Z0, X1'], [0.2, 'Z1']]`` 。 + Args: - H (list): 可观测量的相关信息 + H (Hamiltonian or list): 可观测量的相关信息 + shots (int, optional): 测量次数；默认为 0，表示返回期望值的精确值，即测量无穷次后的期望值 + Returns: - Tensor: 量子电路输出的量子态关于 H 的期望值 + Tensor: 量子电路输出的量子态关于 ``H`` 的期望值 代码示例: - + .. code-block:: python - + + import numpy as np import paddle from paddle_quantum.circuit import UAnsatz + n = 5 + experiment_shots = 2**10 H_info = [[0.1, 'x1'], [0.2, 'y0,z4']] theta = paddle.ones([3], dtype='float64') + cir = UAnsatz(n) cir.rx(theta[0], 0) cir.rz(theta[1], 1) cir.rx(theta[2], 2) cir.run_state_vector() - expect_value = cir.expecval(H_info).numpy() - print(f'Calculated expectation value of {H_info} is {expect_value}') - :: + result_1 = cir.expecval(H_info, shots = experiment_shots).numpy() + result_2 = cir.expecval(H_info, shots = 0).numpy() + + print(f'The expectation value obtained by {experiment_shots} measurements is {result_1}') + print(f'The accurate expectation value of H is {result_2}') - Calculated expectation value of [[0.1, 'x1'], [0.2, 'y0,z4']] is [-0.1682942] + :: + The expectation value obtained by 1024 measurements is [-0.16328125] + The accurate expectation value of H is [-0.1682942] """ - if self.__run_state == 'state_vector': - return real(vec_expecval(H, self.__state)) - elif self.__run_state == 'density_matrix': - state = self.__state - H_mat = paddle.to_tensor(pauli_str_to_matrix(H, self.n)) - return real(trace(matmul(state, H_mat))) + expec_val = 0 + if not isinstance(H, list): + H = H.pauli_str + if shots == 0: + if self.__run_mode == 'state_vector': + expec_val = real(vec_expecval(H, self.__state)) + elif self.__run_mode == 'density_matrix': + state = self.__state + H_mat = paddle.to_tensor(pauli_str_to_matrix(H, self.n)) + expec_val = real(trace(matmul(state, H_mat))) + else: + # Raise error + raise ValueError("no state for measurement; please run the circuit first") else: - # Raise error - raise ValueError("no state for measurement; please run the circuit first") + for term in H: + expec_val += term[0] * _local_H_prob(self, term[1], shots=shots) + expec_val = paddle.to_tensor(expec_val, 'float64') + + return expec_val """ Circuit Templates @@ -1269,7 +2552,7 @@ class UAnsatz: 代码示例: .. code-block:: python - + import paddle from paddle_quantum.circuit import UAnsatz cir = UAnsatz(2) @@ -1280,7 +2563,9 @@ class UAnsatz: :: - The probability distribution of measurement results on both qubits is {'00': 0.2499999999999999, '01': 0.2499999999999999, '10': 0.2499999999999999, '11': 0.2499999999999999} + The probability distribution of measurement results on both qubits is + {'00': 0.2499999999999999, '01': 0.2499999999999999, + '10': 0.2499999999999999, '11': 0.2499999999999999} """ for i in range(self.n): self.h(i) @@ -1291,7 +2576,7 @@ class UAnsatz: 代码示例: .. code-block:: python - + import paddle from paddle_quantum.circuit import UAnsatz cir = UAnsatz(2) @@ -1302,7 +2587,9 @@ class UAnsatz: :: - The probability distribution of measurement results on both qubits is {'00': 0.7285533905932737, '01': 0.12500000000000003, '10': 0.12500000000000003, '11': 0.021446609406726238} + The probability distribution of measurement results on both qubits is + {'00': 0.7285533905932737, '01': 0.12500000000000003, + '10': 0.12500000000000003, '11': 0.021446609406726238} """ _theta = paddle.to_tensor(np.array([np.pi / 4])) # Used in fixed Ry gate for i in range(self.n): @@ -1312,12 +2599,12 @@ class UAnsatz: r"""添加 ``depth`` 层包含 Ry 门，Rz 门和 CNOT 门的线性纠缠层。 Attention: - ``theta`` 的维度为 ``(depth, n, 2)`` ，最低维内容为对应的 ``ry`` 和 ``rz`` 的参数。 + ``theta`` 的维度为 ``(depth, n, 2)`` ，最低维内容为对应的 ``ry`` 和 ``rz`` 的参数， ``n`` 为作用的量子比特数量。 Args: theta (Tensor): Ry 门和 Rz 门的旋转角度 depth (int): 纠缠层的深度 - which_qubits(list): 作用的量子比特编号 + which_qubits (list): 作用的量子比特编号 代码示例: @@ -1327,16 +2614,25 @@ class UAnsatz: from paddle_quantum.circuit import UAnsatz n = 2 DEPTH = 3 - theta = paddle.ones([DEPTH, n, 2], dtype='float64') + theta = paddle.ones([DEPTH, 2, 2], dtype='float64') cir = UAnsatz(n) cir.linear_entangled_layer(theta, DEPTH, [0, 1]) cir.run_state_vector() - print(cir.measure(shots = 0)) + result = cir.measure(shots = 0) + print(f"The probability distribution of measurement results on both qubits is {result}") :: - {'00': 0.646611169077063, '01': 0.06790630495474384, '10': 0.19073671025717626, '11': 0.09474581571101756} + The probability distribution of measurement results on both qubits is + {'00': 0.646611169077063, '01': 0.06790630495474384, + '10': 0.19073671025717626, '11': 0.09474581571101756} """ + # reformat 1D theta list + theta_flat = paddle.flatten(theta) + width = len(which_qubits) if which_qubits is not None else self.n + assert len(theta_flat) == depth * width * 2, 'the size of theta is not right' + theta = paddle.reshape(theta_flat, [depth, width, 2]) + assert self.n > 1, 'you need at least 2 qubits' assert len(theta.shape) == 3, 'the shape of theta is not right' assert theta.shape[2] == 2, 'the shape of theta is not right' @@ -1363,12 +2659,12 @@ class UAnsatz: 这一层量子门的数学表示形式为实数酉矩阵。 Attention: - ``theta`` 的维度为 ``(depth, n, 1)`` 。 + ``theta`` 的维度为 ``(depth, n, 1)``， ``n`` 为作用的量子比特数量。 Args: theta (Tensor): Ry 门的旋转角度 depth (int): 纠缠层的深度 - which_qubits(list): 作用的量子比特编号 + which_qubits (list): 作用的量子比特编号 代码示例: @@ -1378,16 +2674,25 @@ class UAnsatz: from paddle_quantum.circuit import UAnsatz n = 2 DEPTH = 3 - theta = paddle.ones([DEPTH, n, 1], dtype='float64') + theta = paddle.ones([DEPTH, 2, 1], dtype='float64') cir = UAnsatz(n) cir.real_entangled_layer(paddle.to_tensor(theta), DEPTH, [0, 1]) cir.run_state_vector() - print(cir.measure(shots = 0)) - + result = cir.measure(shots = 0) + print(f"The probability distribution of measurement results on both qubits is {result}") + :: - {'00': 2.52129874867343e-05, '01': 0.295456784923382, '10': 0.7045028818254718, '11': 1.5120263659845063e-05} + The probability distribution of measurement results on both qubits is + {'00': 2.52129874867343e-05, '01': 0.295456784923382, + '10': 0.7045028818254718, '11': 1.5120263659845063e-05} """ + # reformat 1D theta list + theta_flat = paddle.flatten(theta) + width = len(which_qubits) if which_qubits is not None else self.n + assert len(theta_flat) == depth * width, 'the size of theta is not right' + theta = paddle.reshape(theta_flat, [depth, width, 1]) + assert self.n > 1, 'you need at least 2 qubits' assert len(theta.shape) == 3, 'the shape of theta is not right' assert theta.shape[2] == 1, 'the shape of theta is not right' @@ -1409,33 +2714,42 @@ class UAnsatz: Note: 这一层量子门的数学表示形式为复数酉矩阵。 - + Attention: - ``theta`` 的维度为 ``(depth, n, 3)`` ，最低维内容为对应的 ``u3`` 的参数 ``(theta, phi, lam)`` 。 - + ``theta`` 的维度为 ``(depth, n, 3)`` ，最低维内容为对应的 ``u3`` 的参数 ``(theta, phi, lam)``， ``n`` 为作用的量子比特数量。 + Args: theta (Tensor): U3 门的旋转角度 depth (int): 纠缠层的深度 - which_qubits(list): 作用的量子比特编号 + which_qubits (list): 作用的量子比特编号 代码示例: .. code-block:: python - + import paddle from paddle_quantum.circuit import UAnsatz n = 2 DEPTH = 3 - theta = paddle.ones([DEPTH, n, 3], dtype='float64') + theta = paddle.ones([DEPTH, 2, 3], dtype='float64') cir = UAnsatz(n) cir.complex_entangled_layer(paddle.to_tensor(theta), DEPTH, [0, 1]) cir.run_state_vector() - print(cir.measure(shots = 0)) - + result = cir.measure(shots = 0) + print(f"The probability distribution of measurement results on both qubits is {result}") + :: - {'00': 0.15032627279218896, '01': 0.564191201239618, '10': 0.03285998070292556, '11': 0.25262254526526823} + The probability distribution of measurement results on both qubits is + {'00': 0.15032627279218896, '01': 0.564191201239618, + '10': 0.03285998070292556, '11': 0.25262254526526823} """ + # reformat 1D theta list + theta_flat = paddle.flatten(theta) + width = len(which_qubits) if which_qubits is not None else self.n + assert len(theta_flat) == depth * width * 3, 'the size of theta is not right' + theta = paddle.reshape(theta_flat, [depth, width, 3]) + assert self.n > 1, 'you need at least 2 qubits' assert len(theta.shape) == 3, 'the shape of theta is not right' assert theta.shape[2] == 3, 'the shape of theta is not right' @@ -1488,24 +2802,26 @@ class UAnsatz: def __add_real_layer(self, theta, position): r""" - Add a real layer on the circuit. theta is a two dimensional tensor. position is the qubit range the layer needs to cover + Add a real layer on the circuit. theta is a two dimensional tensor. + position is the qubit range the layer needs to cover. Note: 这是内部函数，你并不需要直接调用到该函数。 """ - assert theta.shape[1] == 4 and theta.shape[0] == (position[1] - position[0] + 1) / 2,\ + assert theta.shape[1] == 4 and theta.shape[0] == (position[1] - position[0] + 1) / 2, \ 'the shape of theta is not right' for i in range(position[0], position[1], 2): self.__add_real_block(theta[int((i - position[0]) / 2)], [i, i + 1]) def __add_complex_layer(self, theta, position): r""" - Add a complex layer on the circuit. theta is a two dimensional tensor. position is the qubit range the layer needs to cover + Add a complex layer on the circuit. theta is a two dimensional tensor. + position is the qubit range the layer needs to cover. Note: 这是内部函数，你并不需要直接调用到该函数。 """ - assert theta.shape[1] == 12 and theta.shape[0] == (position[1] - position[0] + 1) / 2,\ + assert theta.shape[1] == 12 and theta.shape[0] == (position[1] - position[0] + 1) / 2, \ 'the shape of theta is not right' for i in range(position[0], position[1], 2): self.__add_complex_block(theta[int((i - position[0]) / 2)], [i, i + 1]) @@ -1515,18 +2831,18 @@ class UAnsatz: Note: 这一层量子门的数学表示形式为实数酉矩阵。 - + Attention: ``theta`` 的维度为 ``(depth, n-1, 4)`` 。 - + Args: - theta(Tensor): Ry 门的旋转角度 - depth(int): 纠缠层的深度 + theta (Tensor): Ry 门的旋转角度 + depth (int): 纠缠层的深度 代码示例: .. code-block:: python - + import paddle from paddle_quantum.circuit import UAnsatz n = 4 @@ -1536,7 +2852,7 @@ class UAnsatz: cir.real_block_layer(paddle.to_tensor(theta), DEPTH) cir.run_density_matrix() print(cir.measure(shots = 0, which_qubits = [0])) - + :: {'0': 0.9646724056906162, '1': 0.035327594309385896} @@ -1573,7 +2889,7 @@ class UAnsatz: 代码示例: .. code-block:: python - + import paddle from paddle_quantum.circuit import UAnsatz n = 4 @@ -1583,7 +2899,7 @@ class UAnsatz: cir.complex_block_layer(paddle.to_tensor(theta), DEPTH) cir.run_density_matrix() print(cir.measure(shots = 0, which_qubits = [0])) - + :: {'0': 0.5271554811768046, '1': 0.4728445188231988} @@ -1604,6 +2920,155 @@ class UAnsatz: self.__add_complex_layer(theta[i][:int((self.n - 1) / 2)], [0, self.n - 2]) self.__add_complex_layer(theta[i][int((self.n - 1) / 2):], [1, self.n - 1]) + def finite_difference_gradient(self, H, delta, shots=0): + r"""用差分法估计电路中参数的梯度。损失函数默认为计算哈密顿量的期望值。 + + Args: + H (list or Hamiltonian): 记录哈密顿量信息的列表或 ``Hamiltonian`` 类的对象 + delta (float): 差分法中的 delta + shots (int, optional): 测量次数；默认为 0，表示返回期望值的精确值，即测量无穷次后的期望值 + + Returns: + Tensor: 电路中所有可训练参数的梯度 + + 代码示例: + + .. code-block:: python + + import paddle + import numpy as np + from paddle_quantum.circuit import UAnsatz + + H = [[1.0, 'z0,z1']] + theta = paddle.to_tensor(np.array([6.186, 5.387, 1.603, 1.998]), stop_gradient=False) + + cir = UAnsatz(2) + cir.ry(theta[0], 0) + cir.ry(theta[1], 1) + cir.cnot([0, 1]) + cir.cnot([1, 0]) + cir.ry(theta[2], 0) + cir.ry(theta[3], 1) + cir.run_state_vector() + + gradients = cir.finite_difference_gradient(H, delta=0.01, shots=0) + print(gradients) + + :: + + Tensor(shape=[4], dtype=float64, place=CPUPlace, stop_gradient=False, + [0.01951135, 0.56594233, 0.37991172, 0.35337436]) + """ + grad = [] + for i, theta_i in enumerate(self.__param): + if theta_i.stop_gradient: + continue + self.__param[i] += delta / 2 + self.run_state_vector() + expec_plu = self.expecval(H, shots) + self.__param[i] -= delta + self.run_state_vector() + expec_min = self.expecval(H, shots) + self.__param[i] += delta / 2 + self.run_state_vector() + grad.append(paddle.to_tensor((expec_plu - expec_min) / delta, 'float64')) + self.__param[i].stop_gradient = False + grad = paddle.concat(grad) + grad.stop_gradient = False + + return grad + + def param_shift_gradient(self, H, shots=0): + r"""用 parameter-shift 方法计算电路中参数的梯度。损失函数默认为计算哈密顿量的期望值。 + + Args: + H (list or Hamiltonian): 记录哈密顿量信息的列表或 ``Hamiltonian`` 类的对象 + shots (int, optional): 测量次数；默认为 0，表示返回期望值的精确值，即测量无穷次后的期望值 + + Returns: + Tensor: 电路中所有可训练参数的梯度 + + 代码示例: + + .. code-block:: python + + import numpy as np + import paddle + from paddle_quantum.circuit import UAnsatz + + H = [[1.0, 'z0,z1']] + theta = paddle.to_tensor(np.array([6.186, 5.387, 1.603, 1.998]), stop_gradient=False) + + cir = UAnsatz(2) + cir.ry(theta[0], 0) + cir.ry(theta[1], 1) + cir.cnot([0, 1]) + cir.cnot([1, 0]) + cir.ry(theta[2], 0) + cir.ry(theta[3], 1) + cir.run_state_vector() + + gradients = cir.param_shift_gradient(H, shots=0) + print(gradients) + + :: + + Tensor(shape=[4], dtype=float64, place=CPUPlace, stop_gradient=False, + [0.01951143, 0.56594470, 0.37991331, 0.35337584]) + """ + r = 1 / 2 + grad = [] + for i, theta_i in enumerate(self.__param): + if theta_i.stop_gradient: + continue + self.__param[i] += np.pi / (4 * r) + self.run_state_vector() + f_plu = self.expecval(H, shots) + self.__param[i] -= 2 * np.pi / (4 * r) + self.run_state_vector() + f_min = self.expecval(H, shots) + self.__param[i] += np.pi / (4 * r) + self.run_state_vector() + grad.append(paddle.to_tensor(r * (f_plu - f_min), 'float64')) + self.__param[i].stop_gradient = False + grad = paddle.concat(grad) + grad.stop_gradient = False + + return grad + + def get_param(self): + r"""得到电路参数列表中的可训练的参数。 + + Returns: + list: 电路中所有可训练的参数 + """ + param = [] + for theta in self.__param: + if not theta.stop_gradient: + param.append(theta) + assert len(param) != 0, "circuit does not contain trainable parameters" + param = paddle.concat(param) + param.stop_gradient = False + return param + + def update_param(self, new_param): + r"""用得到的新参数列表更新电路参数列表中的可训练的参数。 + + Args: + new_param (list): 新的参数列表 + + Returns: + Tensor: 更新后电路中所有训练的参数 + """ + j = 0 + for i in range(len(self.__param)): + if not self.__param[i].stop_gradient: + self.__param[i] = paddle.to_tensor(new_param[j], 'float64') + self.__param[i].stop_gradient = False + j += 1 + self.run_state_vector() + return self.__param + """ Channels """ @@ -1613,11 +3078,19 @@ class UAnsatz: r"""添加振幅阻尼信道。 其 Kraus 算符为： - + .. math:: - E_0 = \begin{bmatrix} 1 & 0 \\ 0 & \sqrt{1-\gamma} \end{bmatrix}, - E_1 = \begin{bmatrix} 0 & \sqrt{\gamma} \\ 0 & 0 \end{bmatrix}. + E_0 = + \begin{bmatrix} + 1 & 0 \\ + 0 & \sqrt{1-\gamma} + \end{bmatrix}, + E_1 = + \begin{bmatrix} + 0 & \sqrt{\gamma} \\ + 0 & 0 + \end{bmatrix}. Args: gamma (float): 减振概率，其值应该在 :math:`[0, 1]` 区间内 @@ -1659,7 +3132,11 @@ class UAnsatz: .. math:: - E_0 = \sqrt{p} \begin{bmatrix} 1 & 0 \\ 0 & \sqrt{1-\gamma} \end{bmatrix}, + E_0 = \sqrt{p} + \begin{bmatrix} + 1 & 0 \\ + 0 & \sqrt{1-\gamma} + \end{bmatrix}, E_1 = \sqrt{p} \begin{bmatrix} 0 & \sqrt{\gamma} \\ 0 & 0 \end{bmatrix},\\ E_2 = \sqrt{1-p} \begin{bmatrix} \sqrt{1-\gamma} & 0 \\ 0 & 1 \end{bmatrix}, E_3 = \sqrt{1-p} \begin{bmatrix} 0 & 0 \\ \sqrt{\gamma} & 0 \end{bmatrix}. @@ -1709,8 +3186,16 @@ class UAnsatz: .. math:: - E_0 = \begin{bmatrix} 1 & 0 \\ 0 & \sqrt{1-\gamma} \end{bmatrix}, - E_1 = \begin{bmatrix} 0 & 0 \\ 0 & \sqrt{\gamma} \end{bmatrix}. + E_0 = + \begin{bmatrix} + 1 & 0 \\ + 0 & \sqrt{1-\gamma} + \end{bmatrix}, + E_1 = + \begin{bmatrix} + 0 & 0 \\ + 0 & \sqrt{\gamma} + \end{bmatrix}. Args: gamma (float): phase damping 信道的参数，其值应该在 :math:`[0, 1]` 区间内 @@ -1782,7 +3267,7 @@ class UAnsatz: """ assert 0 <= p <= 1, 'the probability p of a bit flip should be in range [0, 1]' - e0 = paddle.to_tensor([[np.sqrt(1-p), 0], [0, np.sqrt(1-p)]], dtype='complex128') + e0 = paddle.to_tensor([[np.sqrt(1 - p), 0], [0, np.sqrt(1 - p)]], dtype='complex128') e1 = paddle.to_tensor([[0, np.sqrt(p)], [np.sqrt(p), 0]], dtype='complex128') return [e0, e1] @@ -1825,7 +3310,7 @@ class UAnsatz: """ assert 0 <= p <= 1, 'the probability p of a phase flip should be in range [0, 1]' - e0 = paddle.to_tensor([[np.sqrt(1-p), 0], [0, np.sqrt(1-p)]], dtype='complex128') + e0 = paddle.to_tensor([[np.sqrt(1 - p), 0], [0, np.sqrt(1 - p)]], dtype='complex128') e1 = paddle.to_tensor([[np.sqrt(p), 0], [0, -np.sqrt(p)]], dtype='complex128') return [e0, e1] @@ -1868,7 +3353,7 @@ class UAnsatz: """ assert 0 <= p <= 1, 'the probability p of a bit phase flip should be in range [0, 1]' - e0 = paddle.to_tensor([[np.sqrt(1-p), 0], [0, np.sqrt(1-p)]], dtype='complex128') + e0 = paddle.to_tensor([[np.sqrt(1 - p), 0], [0, np.sqrt(1 - p)]], dtype='complex128') e1 = paddle.to_tensor([[0, -1j * np.sqrt(p)], [1j * np.sqrt(p), 0]], dtype='complex128') return [e0, e1] @@ -1913,10 +3398,10 @@ class UAnsatz: """ assert 0 <= p <= 1, 'the parameter p should be in range [0, 1]' - e0 = paddle.to_tensor([[np.sqrt(1-p), 0], [0, np.sqrt(1-p)]], dtype='complex128') - e1 = paddle.to_tensor([[0, np.sqrt(p/3)], [np.sqrt(p/3), 0]], dtype='complex128') - e2 = paddle.to_tensor([[0, -1j * np.sqrt(p/3)], [1j * np.sqrt(p/3), 0]], dtype='complex128') - e3 = paddle.to_tensor([[np.sqrt(p/3), 0], [0, -np.sqrt(p/3)]], dtype='complex128') + e0 = paddle.to_tensor([[np.sqrt(1 - p), 0], [0, np.sqrt(1 - p)]], dtype='complex128') + e1 = paddle.to_tensor([[0, np.sqrt(p / 3)], [np.sqrt(p / 3), 0]], dtype='complex128') + e2 = paddle.to_tensor([[0, -1j * np.sqrt(p / 3)], [1j * np.sqrt(p / 3), 0]], dtype='complex128') + e3 = paddle.to_tensor([[np.sqrt(p / 3), 0], [0, -np.sqrt(p / 3)]], dtype='complex128') return [e0, e1, e2, e3] @@ -1974,29 +3459,45 @@ class UAnsatz: @apply_channel def reset(self, p, q, which_qubit): r"""添加重置信道。有 p 的概率将量子态重置为 :math:`|0\rangle` 并有 q 的概率重置为 :math:`|1\rangle`。 - + 其 Kraus 算符为： - + .. math:: - - E_0 = \begin{bmatrix} \sqrt{p} & 0 \\ 0 & 0 \end{bmatrix}, - E_1 = \begin{bmatrix} 0 & \sqrt{p} \\ 0 & 0 \end{bmatrix},\\ - E_2 = \begin{bmatrix} 0 & 0 \\ \sqrt{q} & 0 \end{bmatrix}, - E_3 = \begin{bmatrix} 0 & 0 \\ 0 & \sqrt{q} \end{bmatrix},\\ + + E_0 = + \begin{bmatrix} + \sqrt{p} & 0 \\ + 0 & 0 + \end{bmatrix}, + E_1 = + \begin{bmatrix} + 0 & \sqrt{p} \\ + 0 & 0 + \end{bmatrix},\\ + E_2 = + \begin{bmatrix} + 0 & 0 \\ + \sqrt{q} & 0 + \end{bmatrix}, + E_3 = + \begin{bmatrix} + 0 & 0 \\ + 0 & \sqrt{q} + \end{bmatrix},\\ E_4 = \sqrt{1-p-q} I. - + Args: p (float): 重置为 :math:`|0\rangle`的概率，其值应该在 :math:`[0, 1]` 区间内 q (float): 重置为 :math:`|1\rangle`的概率，其值应该在 :math:`[0, 1]` 区间内 which_qubit (int): 该信道作用在的 qubit 的编号，其值应该在 :math:`[0, n)` 范围内， :math:`n` 为该量子电路的量子比特数 - + Note: 两个输入的概率加起来需要小于等于 1。 - + 代码示例: - + .. code-block:: python - + from paddle_quantum.circuit import UAnsatz N = 2 p = 1 @@ -2007,24 +3508,24 @@ class UAnsatz: cir.reset(p, q, 0) final_state = cir.run_density_matrix() print(final_state.numpy()) - + :: - + [[0.5+0.j 0. +0.j 0. +0.j 0. +0.j] [0. +0.j 0.5+0.j 0. +0.j 0. +0.j] [0. +0.j 0. +0.j 0. +0.j 0. +0.j] [0. +0.j 0. +0.j 0. +0.j 0. +0.j]] """ assert p + q <= 1, 'the sum of probabilities should be smaller than or equal to 1 ' - + e0 = paddle.to_tensor([[np.sqrt(p), 0], [0, 0]], dtype='complex128') e1 = paddle.to_tensor([[0, np.sqrt(p)], [0, 0]], dtype='complex128') e2 = paddle.to_tensor([[0, 0], [np.sqrt(q), 0]], dtype='complex128') e3 = paddle.to_tensor([[0, 0], [0, np.sqrt(q)]], dtype='complex128') e4 = paddle.to_tensor([[np.sqrt(1 - (p + q)), 0], [0, np.sqrt(1 - (p + q))]], dtype='complex128') - + return [e0, e1, e2, e3, e4] - + @apply_channel def thermal_relaxation(self, t1, t2, time, which_qubit): r"""添加热弛豫信道，模拟超导硬件上的 T1 和 T2 混合过程。 @@ -2065,23 +3566,23 @@ class UAnsatz: """ assert 0 <= t2 <= t1, 'Relaxation time constants are not valid as 0 <= T2 <= T1!' assert 0 <= time, 'Invalid gate time!' - + # Change time scale time = time / 1000 # Probability of resetting the state to |0> - p_reset = 1 - np.exp(-time / t1) + p_reset = 1 - np.exp(-time / t1) # Probability of phase flip - p_z = (1 - p_reset) * (1 - np.exp(-time / t2) * np.exp(time / t1)) / 2 + p_z = (1 - p_reset) * (1 - np.exp(-time / t2) * np.exp(time / t1)) / 2 # Probability of identity - p_i = 1- p_reset - p_z - + p_i = 1 - p_reset - p_z + e0 = paddle.to_tensor([[np.sqrt(p_i), 0], [0, np.sqrt(p_i)]], dtype='complex128') e1 = paddle.to_tensor([[np.sqrt(p_z), 0], [0, -np.sqrt(p_z)]], dtype='complex128') e2 = paddle.to_tensor([[np.sqrt(p_reset), 0], [0, 0]], dtype='complex128') e3 = paddle.to_tensor([[0, np.sqrt(p_reset)], [0, 0]], dtype='complex128') - + return [e0, e1, e2, e3] - + @apply_channel def customized_channel(self, ops, which_qubit): r"""添加自定义的量子信道。 @@ -2119,10 +3620,246 @@ class UAnsatz: assert op.shape == [2, 2], 'The shape of each operator should be [2, 2].' assert op.dtype.name == 'COMPLEX128', 'The dtype of each operator should be COMPLEX128.' completeness += matmul(dagger(op), op) - assert np.allclose(completeness.numpy(), np.eye(2, dtype='complex128')), 'Kraus operators should satisfy completeness.' + assert np.allclose(completeness.numpy(), + np.eye(2, dtype='complex128')), 'Kraus operators should satisfy completeness.' return ops + def shadow_trace(self, hamiltonian, sample_shots, method='CS'): + r"""估计可观测量 :math:`H` 的期望值 :math:`\text{trace}(H\rho)` 。 + + Args: + hamiltonian (Hamiltonian): 可观测量 + sample_shots (int): 采样次数 + method (str, optional): 使用 shadow 来进行估计的方法，可选 "CS"、"LBCS"、"APS" 三种方法，默认为 "CS" + + 代码示例: + + .. code-block:: python + + import paddle + from paddle_quantum.circuit import UAnsatz + from paddle_quantum.utils import Hamiltonian + from paddle_quantum.state import vec_random + + n_qubit = 2 + sample_shots = 1000 + state = vec_random(n_qubit) + ham = [[0.1, 'x1'], [0.2, 'y0']] + ham = Hamiltonian(ham) + + cir = UAnsatz(n_qubit) + input_state = cir.run_state_vector(paddle.to_tensor(state)) + trace_cs = cir.shadow_trace(ham, sample_shots, method="CS") + trace_lbcs = cir.shadow_trace(ham, sample_shots, method="LBCS") + trace_aps = cir.shadow_trace(ham, sample_shots, method="APS") + + print('trace CS = ', trace_cs) + print('trace LBCS = ', trace_lbcs) + print('trace APS = ', trace_aps) + + :: + + trace CS = -0.09570000000000002 + trace LBCS = -0.0946048044954126 + trace APS = -0.08640438803809354 + """ + if not isinstance(hamiltonian, list): + hamiltonian = hamiltonian.pauli_str + state = self.__state + num_qubits = self.n + mode = self.__run_mode + if method == "LBCS": + result, beta = shadow.shadow_sample(state, num_qubits, sample_shots, mode, hamiltonian, method) + else: + result = shadow.shadow_sample(state, num_qubits, sample_shots, mode, hamiltonian, method) + + def prepare_hamiltonian(hamiltonian, num_qubits): + r"""改写可观测量 ``[[0.3147,'y2'], [-0.5484158742278,'x2,z1'],...]`` 的形式 + + Args: + hamiltonian (list): 可观测量的相关信息 + num_qubits (int): 量子比特数目 + + Returns: + list: 可观测量的形式改写为[[0.3147,'iiy'], [-0.5484158742278,'izx'],...] + + Note: + 这是内部函数，你并不需要直接调用到该函数。 + """ + new_hamiltonian = list() + for idx, (coeff, pauli_str) in enumerate(hamiltonian): + pauli_str = re.split(r',\s*', pauli_str.lower()) + pauli_term = ['i'] * num_qubits + for item in pauli_str: + if len(item) > 1: + pauli_term[int(item[1:])] = item[0] + elif item[0].lower() != 'i': + raise ValueError('Expecting I for ', item[0]) + new_term = [coeff, ''.join(pauli_term)] + new_hamiltonian.append(new_term) + return new_hamiltonian + + hamiltonian = prepare_hamiltonian(hamiltonian, num_qubits) + + sample_pauli_str = [item for item, _ in result] + sample_measurement_result = [item for _, item in result] + coeff_terms = list() + pauli_terms = list() + for coeff, pauli_term in hamiltonian: + coeff_terms.append(coeff) + pauli_terms.append(pauli_term) + + pauli2idx = {'x': 0, 'y': 1, 'z': 2} + + def estimated_weight_cs(sample_pauli_str, pauli_term): + r"""定义 CS 算法中的对测量的权重估计函数 + + Args: + sample_pauli_str (str): 随机选择的 pauli 项 + pauli_term (str): 可观测量的 pauli 项 + + Returns: + int: 返回估计的权重值 + + Note: + 这是内部函数，你并不需要直接调用到该函数。 + """ + result = 1 + for i in range(num_qubits): + if sample_pauli_str[i] == 'i' or pauli_term[i] == 'i': + continue + elif sample_pauli_str[i] == pauli_term[i]: + result *= 3 + else: + result = 0 + return result + + def estimated_weight_lbcs(sample_pauli_str, pauli_term, beta): + r"""定义 LBCS 算法中的权重估计函数 + + Args: + sample_pauli_str (str): 随机选择的 pauli 项 + pauli_term (str): 可观测量的 pauli 项 + beta (list): 所有量子位上关于 pauli 的概率分布 + + Returns: + float: 返回函数数值 + + Note: + 这是内部函数，你并不需要直接调用到该函数。 + """ + # beta is 2-d, and the shape looks like (len, 3) + assert len(sample_pauli_str) == len(pauli_term) + result = 1 + for i in range(num_qubits): + # The probability distribution is different at each qubit + score = 0 + idx = pauli2idx[sample_pauli_str[i]] + if sample_pauli_str[i] == 'i' or pauli_term[i] == 'i': + score = 1 + elif sample_pauli_str[i] == pauli_term[i] and beta[i][idx] != 0: + score = 1 / beta[i][idx] + result *= score + return result + + def estimated_value(pauli_term, measurement_result): + r"""满足条件的测量结果本征值的乘积 + + Args: + pauli_term (str): 可观测量的 pauli 项 + measurement_result (list): 测量结果 + + Returns: + int: 返回测量结果本征值的乘积 + + Note: + 这是内部函数，你并不需要直接调用到该函数。 + """ + value = 1 + for idx in range(num_qubits): + if pauli_term[idx] != 'i' and measurement_result[idx] == '1': + value *= -1 + return value + + # Define the functions required by APS + def is_covered(pauli, pauli_str): + r"""判断可观测量的 pauli 项是否被随机选择的 pauli 项所覆盖 + + Args: + pauli (str): 可观测量的 pauli 项 + pauli_str (str): 随机选择的 pauli 项 + + Note: + 这是内部函数，你并不需要直接调用到该函数。 + """ + for qubit_idx in range(num_qubits): + if not pauli[qubit_idx] in ('i', pauli_str[qubit_idx]): + return False + return True + + def update_pauli_estimator(hamiltonian, pauli_estimator, pauli_str, measurement_result): + r"""用于更新 APS 算法下当前可观测量 pauli 项 P 的最佳估计 tr( P \rho)，及 P 被覆盖的次数 + + Args: + hamiltonian (list): 可观测量的相关信息 + pauli_estimator (dict): 用于记录最佳估计与被覆盖次数 + pauli_str (list): 随机选择的 pauli 项 + measurement_result (list): 对随机选择的 pauli 项测量得到的结果 + + Note: + 这是内部函数，你并不需要直接调用到该函数。 + """ + for coeff, pauli_term in hamiltonian: + last_estimator = pauli_estimator[pauli_term]['value'][-1] + if is_covered(pauli_term, pauli_str): + value = estimated_value(pauli_term, measurement_result) + chose_number = pauli_estimator[pauli_term]['times'] + new_estimator = 1 / (chose_number + 1) * (chose_number * last_estimator + value) + pauli_estimator[pauli_term]['times'] += 1 + pauli_estimator[pauli_term]['value'].append(new_estimator) + else: + pauli_estimator[pauli_term]['value'].append(last_estimator) + + trace_estimation = 0 + if method == "CS": + for sample_idx in range(sample_shots): + estimation = 0 + for i in range(len(pauli_terms)): + value = estimated_value(pauli_terms[i], sample_measurement_result[sample_idx]) + weight = estimated_weight_cs(sample_pauli_str[sample_idx], pauli_terms[i]) + estimation += coeff_terms[i] * weight * value + trace_estimation += estimation + trace_estimation /= sample_shots + elif method == "LBCS": + for sample_idx in range(sample_shots): + estimation = 0 + for i in range(len(pauli_terms)): + value = estimated_value(pauli_terms[i], sample_measurement_result[sample_idx]) + weight = estimated_weight_lbcs(sample_pauli_str[sample_idx], pauli_terms[i], beta) + estimation += coeff_terms[i] * weight * value + trace_estimation += estimation + trace_estimation /= sample_shots + elif method == "APS": + # Create a search dictionary for easy storage + pauli_estimator = dict() + for coeff, pauli_term in hamiltonian: + pauli_estimator[pauli_term] = {'times': 0, 'value': [0]} + for sample_idx in range(sample_shots): + update_pauli_estimator( + hamiltonian, + pauli_estimator, + sample_pauli_str[sample_idx], + sample_measurement_result[sample_idx] + ) + for sample_idx in range(sample_shots): + estimation = 0 + for coeff, pauli_term in hamiltonian: + estimation += coeff * pauli_estimator[pauli_term]['value'][sample_idx + 1] + trace_estimation = estimation + + return trace_estimation + def _local_H_prob(cir, hamiltonian, shots=1024): r""" @@ -2141,13 +3878,16 @@ def _local_H_prob(cir, hamiltonian, shots=1024): # Set up pauli measurement circuit for op in op_list: element = op[0] - index = int(op[1:]) - if element == 'x': + if len(op) > 1: + index = int(op[1:]) + elif op[0].lower() != 'i': + raise ValueError('Expecting {} to be {}'.format(op, 'I')) + if element.lower() == 'x': new_cir.h(index) new_cir.cnot([index, cir.n]) - elif element == 'z': + elif element.lower() == 'z': new_cir.cnot([index, cir.n]) - elif element == 'y': + elif element.lower() == 'y': new_cir.rz(_theta, index) new_cir.h(index) new_cir.cnot([index, cir.n]) @@ -2159,7 +3899,7 @@ def _local_H_prob(cir, hamiltonian, shots=1024): if '0' in prob_result: result = (prob_result['0']) / shots else: - result = (prob_result['1']) / shots + result = -(prob_result['1']) / shots else: result = (prob_result['0'] - prob_result['1']) / shots else: @@ -2168,44 +3908,46 @@ def _local_H_prob(cir, hamiltonian, shots=1024): return result -def H_prob(cir, H, shots=1024): - r"""构造 Pauli 测量电路并测量关于 H 的期望值。 +def swap_test(n): + r"""构造用 Swap Test 测量两个量子态之间差异的电路。 Args: - cir (UAnsatz): UAnsatz 的一个实例化对象 - H (list): 记录哈密顿量信息的列表 - shots (int, optional): 默认为 1024，表示测量次数；若为 0，则表示返回测量期望值的精确值，即测量无穷次后的期望值 + n (int): 待比较的两个态的量子比特数 Returns: - float: 测量得到的H的期望值 - + UAnsatz: Swap Test 的电路 + 代码示例: .. code-block:: python - - import numpy as np + import paddle - from paddle_quantum.circuit import UAnsatz, H_prob - n = 4 - experiment_shots = 2**10 - H_info = [[0.1, 'x2'], [0.3, 'y1,z3']] - - theta = paddle.to_tensor(np.ones(3)) - cir = UAnsatz(n) - cir.rx(theta[0], 0) - cir.ry(theta[1], 1) - cir.rz(theta[2], 1) - result_1 = H_prob(cir, H_info, shots = experiment_shots) - result_2 = H_prob(cir, H_info, shots = 0) - print(f'The expectation value obtained by {experiment_shots} measurements is {result_1}') - print(f'The accurate expectation value of H is {result_2}') + import numpy as np + from paddle_quantum.state import vec + from paddle_quantum.circuit import UAnsatz, swap_test + from paddle_quantum.utils import NKron + + n = 2 + ancilla = vec(0, 1) + psi = vec(1, n) + phi = vec(0, n) + input_state = NKron(ancilla, psi, phi) + + cir = swap_test(n) + cir.run_state_vector(paddle.to_tensor(input_state)) + result = cir.measure(which_qubits=[0], shots=8192, plot=True) + probability = result['0'] / 8192 + inner_product = (probability - 0.5) * 2 + print(f"The inner product is {inner_product}") :: - The expectation value obtained by 1024 measurements is 0.2177734375 - The accurate expectation value of H is 0.21242202548207134 + The inner product is 0.006591796875 """ - expval = 0 - for term in H: - expval += term[0] * _local_H_prob(cir, term[1], shots=shots) - return expval + cir = UAnsatz(2 * n + 1) + cir.h(0) + for i in range(n): + cir.cswap([0, i + 1, i + n + 1]) + cir.h(0) + + return cir diff --git a/paddle_quantum/expecval.py b/paddle_quantum/expecval.py new file mode 100644 index 0000000..58269d6 --- /dev/null +++ b/paddle_quantum/expecval.py @@ -0,0 +1,143 @@ +# Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +""" +ExpecVal Class +""" + +import paddle +from paddle.autograd import PyLayer + +__all__ = [ + "ExpecVal" +] + + +class ExpecVal(PyLayer): + r"""PaddlePaddle 自定义 Python 算子，用来计算量子电路输出的量子态关于可观测量 H 的期望值。 + """ + + @staticmethod + def forward(ctx, cir, theta, grad_func, hamiltonian, delta=None, shots=0): + r"""前向函数。 + + Hint: + 如果想输入的可观测量的矩阵为 :math:`0.7Z\otimes X\otimes I+0.2I\otimes Z\otimes I` 。则 ``H`` 的 ``list`` 形式为 ``[[0.7, 'Z0, X1'], [0.2, 'Z1']]`` 。 + + Args: + cir (UAnsatz): 目标量子电路 + theta (paddle.Tensor): 量子电路中的需要被优化的参数 + grad_func (string): 用于计算梯度的函数名，应为 ``'finite_diff'`` 或 ``'param_shift'`` + hamiltonian (list or Hamiltonian): 记录哈密顿量信息的列表或 ``Hamiltonian`` 类的对象 + delta (float): 差分法中需要用到的 delta，默认为 ``None`` + shots (int, optional): 表示测量次数；默认为 0，表示返回期望值的精确值，即测量无穷次后的期望值 + + Returns: + paddle.Tensor: 量子电路输出的量子态关于可观测量 H 的期望值 + + 代码示例: + + .. code-block:: python + + import numpy as np + import paddle + from paddle_quantum.circuit import UAnsatz + from paddle_quantum.expecval import ExpecVal + + N = 2 + D = 2 + theta = paddle.uniform(shape=[N * D], dtype='float64', min=0.0, max=np.pi * 2) + theta.stop_gradient = False + cir = UAnsatz(N) + cir.real_entangled_layer(theta, D) + cir.run_state_vector() + + H = [[1.0, 'z0,z1']] + delta = 0.01 + shots = 0 + + z = ExpecVal.apply(cir, cir.get_param(), 'finite_diff', H, delta, shots) + print(z) + + :: + + Tensor(shape=[1], dtype=float64, place=CPUPlace, stop_gradient=False, + [0.61836319]) + """ + assert grad_func in {'finite_diff', 'param_shift'}, "grad_func must be one of 'finite_diff' or 'param_shift'" + # Pass grad_func, cir, theta, delta, shots, and Hamiltonian into the backward function by adding temporary attributes + ctx.grad_func = grad_func + ctx.cir = cir + ctx.theta = theta + ctx.delta = delta + ctx.shots = shots + ctx.Hamiltonian = hamiltonian + + # Compute the expectation value + cir.update_param(theta) + expec_val = cir.expecval(ctx.Hamiltonian, shots) + + return expec_val + + @staticmethod + def backward(ctx, dy): + r"""反向函数。 + + Args: + dy (paddle.Tensor): 前向函数输出的期望值的梯度 + + Returns: + paddle.Tensor: 前向函数中输入的参数 ``theta`` 的梯度 + + 代码示例: + + .. code-block:: python + + import numpy as np + import paddle + from paddle_quantum.circuit import UAnsatz + from paddle_quantum.expecval import ExpecVal + + N = 2 + D = 2 + theta = paddle.uniform(shape=[N * D], dtype='float64', min=0.0, max=np.pi * 2) + theta.stop_gradient = False + cir = UAnsatz(N) + cir.real_entangled_layer(theta, D) + cir.run_state_vector() + + H = [[1.0, 'z0,z1']] + delta = 0.01 + shots = 0 + + z = ExpecVal.apply(cir, cir.get_param(), 'finite_diff', H, delta, shots) + temp = paddle.square(z) + temp.backward() + """ + # Get expec_func, grad_func, theta, delta, and args + cir = ctx.cir + grad_func = ctx.grad_func + delta = ctx.delta + shots = ctx.shots + Hamiltonian = ctx.Hamiltonian + + # Compute the gradient + if grad_func == "finite_diff": + assert delta is not None, "Finite difference gradient requires an input 'delta'" + grad = dy * cir.finite_difference_gradient(Hamiltonian, delta, shots) + else: + grad = dy * cir.param_shift_gradient(Hamiltonian, shots) + grad.stop_gradient = False + + return paddle.reshape(grad, ctx.theta.shape) diff --git a/paddle_quantum/finance.py b/paddle_quantum/finance.py new file mode 100644 index 0000000..ec1bfb7 --- /dev/null +++ b/paddle_quantum/finance.py @@ -0,0 +1,357 @@ +# Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +""" +Functions and data simulator class of quantum finance +""" + +import fastdtw +import numpy as np +from paddle_quantum.utils import Hamiltonian + +__all__ = [ + "DataSimulator", + "portfolio_optimization_hamiltonian", + "portfolio_diversification_hamiltonian", + "arbitrage_opportunities_hamiltonian" +] + + +class DataSimulator: + r"""用于生成和计算投资组合优化和投资分散化问题要用的数据和相关参数 + + """ + def __init__(self, stocks, start=None, end=None): + r"""构造函数，用于实例化一个 ``DataSimulator`` 对象。 + + Args: + stocks (list): 表示所有可投资股票的名字 + start (datetime): 默认为 ``None``，表示随机生成股票数据时交易日的起始日期 + end (datetime): 默认为 ``None``，表示随机生成股票数据时交易日的结束日期 + """ + self._n = len(stocks) + self._stocks = stocks + + if start and end: + self._start = start + self._end = end + + self._data = [] + + self.asset_return_mean = None + self.asset_return_cov = None + + def set_data(self, data): + r"""决定实验使用的数据是随机生成的还是用户本地输入的 + + Args: + data (list): 用户输入的股票数据 + """ + if len(data) == self._n: + self._data = data + else: + print("invalid data, data is still empty.") + self._data = [] + + def randomly_generate(self): + r"""根据开始日期和结束日期随机生成用于实验的股票数据 + + Note: + 若要随机生成股票数据，需要以 ``datetime`` 包中的格式指定开始日期和结束日期，如 ``start = datetime.datetime(2016, 1, 1)`` + """ + + if self._start and self._end: + num_days = (self._end - self._start).days + for _ in self._stocks: + fluctuation = np.random.standard_normal(num_days) + fluctuation = np.cumsum(fluctuation) + data_i = np.random.randint(1, 101, size=1) + fluctuation + trimmed_data_i = [max(data_i[j], 0) for j in range(num_days)] + if 0 in trimmed_data_i: + zero_ind = trimmed_data_i.index(0) + trimmed_data_i = trimmed_data_i[:zero_ind] + [0 for _ in range(num_days - zero_ind)] + + self._data.append(trimmed_data_i) + else: + print("Please provide the start time and the end time you want to generate stock data.") + + def get_asset_return_mean_vector(self): + r"""用于计算所有可投资股票的平均投资回报率 + + Returns: + list: 所有可投资的股票的平均投资回报率 + """ + returns = [] + for i in range(self._n): + return_i = [self._data[i][j + 1] / self._data[i][j] - 1 + if self._data[i][j] != 0 + else np.nan for j in range(len(self._data[i]) - 1)] + returns.append(return_i) + self.asset_return_mean = np.mean(returns, axis=1) + + return self.asset_return_mean + + def get_asset_return_covariance_matrix(self): + r"""用于计算所有可投资股票回报率之间的协方差矩阵 + + Returns: + list: 所有可投资股票回报率之间的协方差矩阵 + """ + returns = [] + for i in range(self._n): + return_i = [self._data[i][j + 1] / self._data[i][j] - 1 + if self._data[i][j] != 0 + else np.nan for j in range(len(self._data[i]) - 1)] + returns.append(return_i) + self.asset_return_cov = np.cov(returns) + + return self.asset_return_cov + + def get_similarity_matrix(self): + r"""计算各股票之间的相似矩阵 + + 通过动态时间规整算法（Dynamic Time Warping, DTW）计算两股票之间的相似性 + + Returns: + list: 各股票间的相似矩阵 + """ + self.rho = np.zeros((self._n, self._n)) + for i in range(0, self._n): + self.rho[i, i] = 1 + for j in range(i + 1, self._n): + curr_rho, _ = fastdtw.fastdtw(self._data[i], self._data[j]) + curr_rho = 1 / curr_rho + self.rho[i, j] = curr_rho + self.rho[j, i] = curr_rho + + return self.rho + + +def portfolio_optimization_hamiltonian(penalty, mu, sigma, q, budget): + r"""构建投资组合优化问题的哈密顿量 + + Args: + penalty (int): 惩罚参数 + mu (list): 各股票的预期回报率 + sigma (list): 各股票回报率间的协方差矩阵 + q (float): 投资股票的风险 + budget (int): 投资预算, 即要投资的股票数量 + + .. math:: + + C(x) = q \sum_i \sum_j S_{ji}x_ix_j - \sum_{i}x_i \mu_i + A \left(B - \sum_i x_i\right)^2 + + + Hint: + 将布尔变量 :math:`x_i` 映射到哈密顿矩阵上，:math:`x_i \mapsto \frac{I-Z_i}{2}` + + Returns: + Hamiltonian: 投资组合优化问题的哈密顿量 + """ + n = len(mu) + + H_C_list1 = [] + for i in range(n): + for j in range(n): + sigma_ij = sigma[i][j] + H_C_list1.append([sigma_ij / 4, 'I']) + if i != j: + H_C_list1.append([sigma_ij / 4, 'Z' + str(i) + ',Z' + str(j)]) + else: + H_C_list1.append([sigma_ij / 4, 'I']) + H_C_list1.append([- sigma_ij / 4, 'Z' + str(i)]) + H_C_list1.append([- sigma_ij / 4, 'Z' + str((j))]) + H_C_list1 = [[q * c, s] for (c, s) in H_C_list1] + + H_C_list2 = [] + for i in range(n): + H_C_list2.append([- mu[i] / 2, 'I']) + H_C_list2.append([mu[i] / 2, 'Z' + str(i)]) + + H_C_list3 = [[budget ** 2, 'I']] + for i in range(n): + H_C_list3.append([- 2 * budget / 2, 'I']) + H_C_list3.append([2 * budget / 2, 'Z' + str(i)]) + H_C_list3.append([2 / 4, 'I']) + H_C_list3.append([- 2 / 4, 'Z' + str(i)]) + for ii in range(i): + H_C_list3.append([2 / 4, 'I']) + H_C_list3.append([2 / 4, 'Z' + str(i) + ',Z' + str(ii)]) + H_C_list3.append([- 2 / 4, 'Z' + str(i)]) + H_C_list3.append([- 2 / 4, 'Z' + str(ii)]) + H_C_list3 = [[penalty * c, s] for (c, s) in H_C_list3] + + H_C_list = H_C_list1 + H_C_list2 + H_C_list3 + po_hamiltonian = Hamiltonian(H_C_list) + + return po_hamiltonian + + +def portfolio_diversification_hamiltonian(penalty, rho, q): + r"""构建投资组合分散化问题的哈密顿量 + + Args: + penalty (int): 惩罚参数 + rho (list): 各股票间的相似矩阵 + q (int): 股票聚类的类别数 + + .. math:: + + \begin{aligned} + C_x &= -\sum_{i=1}^{n}\sum_{j=1}^{n}\rho_{ij}x_{ij} + A\left(K- \sum_{j=1}^n y_j \right)^2 + \sum_{i=1}^n A\left(\sum_{j=1}^n 1- x_{ij} \right)^2 \\ + &\quad + \sum_{j=1}^n A\left(x_{jj} - y_j\right)^2 + \sum_{i=1}^n \sum_{j=1}^n A\left(x_{ij}(1 - y_j)\right).\\ + \end{aligned} + + Hint: + 将布尔变量 :math:`x_{ij}` 映射到哈密顿矩阵上，:math:`x_{ij} \mapsto \frac{I-Z_{ij}}{2}` + + Returns: + Hamiltonian: 投资组合分散化问题的哈密顿量 + """ + n = len(rho) + + H_C_list1 = [] + for i in range(n): + for j in range(n): + rho_ij = - rho[i][j] + H_C_list1.append([rho_ij / 2, 'I']) + H_C_list1.append([- rho_ij / 2, 'Z' + str(i * n + j)]) + + H_C_list2 = [[q ** 2, 'I']] + for j in range(n): + H_C_list2.append([- q, 'I']) + H_C_list2.append([q, 'Z' + str(n ** 2 + j)]) + H_C_list2.append([1 / 2, 'I']) + H_C_list2.append([- 1 / 2, 'Z' + str(n ** 2 + j)]) + for jj in range(j): + H_C_list2.append([1 / 2, 'I']) + H_C_list2.append([1 / 2, 'Z' + str(n ** 2 + j) + ',Z' + str(n ** 2 + jj)]) + H_C_list2.append([- 1 / 2, 'Z' + str(n ** 2 + j)]) + H_C_list2.append([- 1 / 2, 'Z' + str(n ** 2 + jj)]) + H_C_list2 = [[penalty * c, s] for (c, s) in H_C_list2] + + H_C_list3 = [] + for i in range(n): + H_C_list3.append([1, 'I']) + for j in range(n): + H_C_list3.append([- 1, 'I']) + H_C_list3.append([1, 'Z' + str(i * n + j)]) + H_C_list3.append([1 / 2, 'I']) + H_C_list3.append([- 1 / 2, 'Z' + str(i * n + j)]) + for jj in range(j): + H_C_list3.append([1 / 2, 'I']) + H_C_list3.append([- 1 / 2, 'Z' + str(i * n + j)]) + H_C_list3.append([1 / 2, 'Z' + str(i * n + j) + ',Z' + str(i * n + jj)]) + H_C_list3.append([- 1 / 2, 'Z' + str(i * n + jj)]) + H_C_list3 = [[penalty * c, s] for (c, s) in H_C_list3] + + H_C_list4 = [] + for j in range(n): + H_C_list4.append([1 / 2, 'I']) + H_C_list4.append([- 1 / 2, 'Z' + str(j * n + j) + ',Z' + str(n ** 2 + j)]) + H_C_list4 = [[penalty * c, s] for (c, s) in H_C_list4] + + H_C_list5 = [] + for i in range(n): + for j in range(n): + H_C_list5.append([1 / 4, 'I']) + H_C_list5.append([- 1 / 4, 'Z' + str(i * n + j)]) + H_C_list5.append([1 / 4, 'Z' + str(n ** 2 + j)]) + H_C_list5.append([- 1 / 4, 'Z' + str(i * n + j) + ',Z' + str(n ** 2 + j)]) + H_C_list5 = [[penalty * c, s] for (c, s) in H_C_list5] + + H_C_list = H_C_list1 + H_C_list2 + H_C_list3 + H_C_list4 + H_C_list5 + pd_hamiltonian = Hamiltonian(H_C_list) + + return pd_hamiltonian + + +def arbitrage_opportunities_hamiltonian(g, penalty, n, K): + r"""构建最佳套利机会问题的哈密顿量 + + Args: + g (networkx.DiGraph): 不同货币市场间转换的图形化表示 + A (int): 惩罚参数 + n (int): 货币种类的数量，即图 g 中的顶点数量 + K (int): 套利回路中包含的顶点数 + + .. math:: + + C(x) = - P(x) + A\sum_{k=0}^{K-1} \left(1 - \sum_{i=0}^{n-1} x_{i,k}\right)^2 + A\sum_{k=0}^{K-1}\sum_{(i,j)\notin E}x_{i,k}x_{j,k+1} + + Hint: + 将布尔变量 :math:`x_{i,k}` 映射到哈密顿矩阵上，:math:`x_{i,k} \mapsto \frac{I-Z_{i,k}}{2}` + + Returns: + Hamiltonian: 最佳套利机会问题的哈密顿量 + """ + nodes = list(g.nodes) + + H_C_list1 = [] + for (i, c) in enumerate(nodes): + for (j, cc) in enumerate(nodes): + if i != j: + c_ij = np.log2(g[c][cc]['weight']) + for t in range(K): + H_C_list1.append([c_ij / 4, 'I']) + H_C_list1.append([c_ij / 4, 'Z' + str(i * n + t) + ',Z' + str((j * n + (t + 1) % K))]) + H_C_list1.append([- c_ij / 4, 'Z' + str(i * n + t)]) + H_C_list1.append([- c_ij / 4, 'Z' + str((j * n + (t + 1) % K))]) + H_C_list1 = [[-c, s] for (c, s) in H_C_list1] + + H_C_list2 = [] + for t in range(K): + H_C_list2.append([1, 'I']) + for i in range(n): + H_C_list2.append([- 2 * 1 / 2, 'I']) + H_C_list2.append([2 * 1 / 2, 'Z' + str(i * n + t)]) + H_C_list2.append([2 / 4, 'I']) + H_C_list2.append([- 2 / 4, 'Z' + str(i * n + t)]) + for ii in range(i): + H_C_list2.append([2 / 4, 'I']) + H_C_list2.append([2 / 4, 'Z' + str(i * n + t) + ',Z' + str(ii * n + t)]) + H_C_list2.append([- 2 / 4, 'Z' + str(i * n + t)]) + H_C_list2.append([- 2 / 4, 'Z' + str(ii * n + t)]) + H_C_list2 = [[penalty * c, s] for (c, s) in H_C_list2] + + H_C_list3 = [] + for t in range(K): + for (i, c) in enumerate(nodes): + for (j, cc) in enumerate(nodes): + if (c, cc) not in g.edges and c != cc: + H_C_list3.append([1 / 4, "I"]) + H_C_list3.append([- 1 / 4, 'Z' + str(i * n + t)]) + H_C_list3.append([- 1 / 4, 'Z' + str((j * n + (t + 1) % K))]) + H_C_list3.append([- 1 / 4, 'Z' + str(i * n + t) + ',Z' + str((j * n + (t + 1) % K))]) + H_C_list3 = [[penalty * c, s] for (c, s) in H_C_list3] + + H_C_list4 = [] + for i in range(n): + H_C_list4.append([1, 'I']) + for t in range(K): + H_C_list4.append([- 2 * 1 / 2, 'I']) + H_C_list4.append([2 * 1 / 2, 'Z' + str(i * n + t)]) + H_C_list4.append([2 / 4, 'I']) + H_C_list4.append([- 2 / 4, 'Z' + str(i * n + t)]) + for tt in range(t): + H_C_list4.append([2 / 4, 'I']) + H_C_list4.append([2 / 4, 'Z' + str(i * n + t) + ',Z' + str(i * n + tt)]) + H_C_list4.append([- 2 / 4, 'Z' + str(i * n + t)]) + H_C_list4.append([- 2 / 4, 'Z' + str(i * n + tt)]) + H_C_list4 = [[penalty * c, s] for (c, s) in H_C_list4] + + H_C_list = H_C_list1 + H_C_list2 + H_C_list3 + H_C_list4 + ao_hamiltonian = Hamiltonian(H_C_list) + + return ao_hamiltonian diff --git a/paddle_quantum/intrinsic.py b/paddle_quantum/intrinsic.py index dd39f72..7e7b4e3 100644 --- a/paddle_quantum/intrinsic.py +++ b/paddle_quantum/intrinsic.py @@ -16,10 +16,11 @@ import math from functools import wraps import numpy as np from numpy import binary_repr - +import re import paddle -from paddle import multiply, add, to_tensor +from paddle import multiply, add, to_tensor, matmul, real, trace from paddle_quantum.simulator import StateTransfer +from paddle_quantum import utils def dic_between2and10(n): @@ -52,11 +53,14 @@ def single_H_vec_i(H, target_vec): Note: 这是内部函数，你并不需要直接调用到该函数。 """ - op_list = H.split(',') + op_list = re.split(r',\s*', H.lower()) coef = 1 + 0*1j # Coefficient for the vector new_vec = list(target_vec) for op in op_list: - pos = int(op[1:]) + if len(op) >= 2: + pos = int(op[1:]) + elif op[0] != 'i': + raise ValueError('only operator "I" can be used without identifying its position') if op[0] == 'x': new_vec[pos] = '0' if target_vec[pos] == '1' else '1' elif op[0] == 'y': @@ -119,7 +123,7 @@ def vec_expecval(H, vec): return result -def transfer_by_history(state, history): +def transfer_by_history(state, history, params): r""" It transforms the input state according to the history given. @@ -127,14 +131,18 @@ def transfer_by_history(state, history): 这是内部函数，你并不需要直接调用到该函数。 """ for history_ele in history: - if history_ele[0] != 'channel': - if history_ele[0] in {'s', 't', 'ry', 'rz', 'rx'}: - state = StateTransfer(state, 'u', history_ele[1], params=history_ele[2]) - elif history_ele[0] == 'MS_gate': - state = StateTransfer(state, 'RXX_gate', history_ele[1], params=history_ele[2]) + if history_ele['gate'] != 'channel': + which_qubit = history_ele['which_qubits'] + parameter = [params[i] for i in history_ele['theta']] if history_ele['theta'] else None + + if history_ele['gate'] in {'s', 't', 'ry', 'rz', 'rx', 'sdg', "tdg"}: + state = StateTransfer(state, 'u', which_qubit, params=parameter) + elif history_ele['gate'] == 'MS_gate': + state = StateTransfer(state, 'RXX_gate', which_qubit, params=parameter) + elif history_ele['gate'] in {'crx', 'cry', 'crz'}: + state = StateTransfer(state, 'CU', which_qubit, params=parameter) else: - state = StateTransfer(state, history_ele[0], history_ele[1], params=history_ele[2]) - + state = StateTransfer(state, history_ele['gate'], which_qubit, params=parameter) return state @@ -154,6 +162,6 @@ def apply_channel(func): assert 0 <= which_qubit < self.n, "the qubit's index should >= 0 and < n(the number of qubit)" self._UAnsatz__has_channel = True ops = func(self, *args) - self._UAnsatz__history.append(['channel', ops, [which_qubit]]) + self._UAnsatz__history.append({'gate': 'channel', 'operators': ops, 'which_qubits': [which_qubit]}) - return inner + return inner \ No newline at end of file diff --git a/paddle_quantum/locc.py b/paddle_quantum/locc.py index fa71ec6..eff3a3c 100644 --- a/paddle_quantum/locc.py +++ b/paddle_quantum/locc.py @@ -251,7 +251,7 @@ class LoccAnsatz(UAnsatz): which_qubit (int): 添加该门量子比特编号 """ which_qubit = self.party[which_qubit] - super(LoccAnsatz, self).z(which_qubit) + super(LoccAnsatz, self).t(which_qubit) def u3(self, theta, phi, lam, which_qubit): r"""添加一个单量子比特的旋转门。 diff --git a/paddle_quantum/optimizer/__init__.py b/paddle_quantum/optimizer/__init__.py new file mode 100644 index 0000000..5fe82ea --- /dev/null +++ b/paddle_quantum/optimizer/__init__.py @@ -0,0 +1,32 @@ +# Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +""" +Export the SciPy optimizers +""" + +from .custom_optimizer import CustomOptimizer +from .conjugate_gradient import ConjugateGradient +from .newton_cg import NewtonCG +from .powell import Powell +from .slsqp import SLSQP +from .powell import Powell + +__all__ = [ + 'CustomOptimizer', + 'ConjugateGradient', + 'NewtonCG', + 'Powell', + 'SLSQP' +] diff --git a/paddle_quantum/optimizer/conjugate_gradient.py b/paddle_quantum/optimizer/conjugate_gradient.py new file mode 100644 index 0000000..8f4ef1d --- /dev/null +++ b/paddle_quantum/optimizer/conjugate_gradient.py @@ -0,0 +1,62 @@ +# Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +""" +CG optimizer +""" + +from scipy import optimize +from .custom_optimizer import CustomOptimizer + +class ConjugateGradient(CustomOptimizer): + r"""ConjugateGradient Optimizer + + 继承 ``CustomOptimizer`` 类，使用 SciPy 里 ConjugateGradient (CG) 的方法优化。此优化器需要说明计算梯度的方法。 + + Attributes: + cir (UAnsatz): 带可训练参数的量子电路 + hamiltonian (list or Hamiltonian): 记录哈密顿量信息的列表或 ``Hamiltonian`` 类的对象 + shots (int): 测量次数；默认为 0，表示返回期望值的精确值，即测量无穷次后的期望值 + grad_func_name (string): 用来计算梯度的函数的函数名，可以选择 'linear_comb'、'finite_diff' 或 'param_shift'，默认为 ``None`` + delta (float): 差分法中的 delta，默认为 0.01 + """ + + def __init__(self, cir, hamiltonian, shots, grad_func_name=None, delta=0.01): + r"""``ConjugateGradient`` 的构造函数。 + + Args: + cir (UAnsatz): 带可训练参数的量子电路 + hamiltonian (list or Hamiltonian): 记录哈密顿量信息的列表或 ``Hamiltonian`` 类的对象 + shots (int): 测量次数；默认为 0，表示返回期望值的精确值，即测量无穷次后的期望值 + grad_func_name (string, optional): 用来计算梯度的函数的函数名，可以选择 'linear_comb'、'finite_diff' 或 'param_shift'，默认为 ``None`` + delta (float, optional): 差分法中的 delta，默认为 0.01 + """ + super().__init__(cir, hamiltonian, shots, grad_func_name, delta) + + def minimize(self, iterations): + r"""最小化给定的损失函数。 + + Args: + iterations (int): 迭代的次数 + """ + opt_res = optimize.minimize( + self.loss_func, + self.cir.get_param().numpy(), + args=(self.cir, self.hamiltonian, self.shots), + method='CG', + jac=self.grad_func, + options={'maxiter': iterations}, + callback=lambda xk: print('loss: ', (self.loss_func(xk, self.cir, self.hamiltonian, self.shots))) + ) + print(opt_res.message) diff --git a/paddle_quantum/optimizer/custom_optimizer.py b/paddle_quantum/optimizer/custom_optimizer.py new file mode 100644 index 0000000..4743879 --- /dev/null +++ b/paddle_quantum/optimizer/custom_optimizer.py @@ -0,0 +1,108 @@ +# Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +""" +Custom optimizer +""" + +from abc import ABC, abstractmethod + +class CustomOptimizer(ABC): + r"""所有 SciPy 优化器的基类。 + + 定义了在用 SciPy 优化器优化时所需的基本功能，如计算期望值和计算梯度的函数。 + + Attributes: + cir (UAnsatz): 带可训练参数的量子电路 + hamiltonian (list or Hamiltonian): 记录哈密顿量信息的列表或 ``Hamiltonian`` 类的对象 + shots (int): 测量次数；默认为 0，表示返回期望值的精确值，即测量无穷次后的期望值 + grad_func_name (string, optional): 用来计算梯度的函数的函数名，可以选择 'linear_comb'、'finite_diff' 或 'param_shift'。 + 只有特定需要梯度的 optimizer 如 ``ConjugateGradient`` 需要，默认为 ``None`` + delta (float, optional): 差分法中的 delta，默认为 0.01 + """ + + + def __init__(self, cir, hamiltonian, shots, grad_func_name=None, delta=0.01): + r"""``CustomOptimizer`` 的构造函数。 + + Args: + cir (UAnsatz): 带可训练参数的量子电路 + hamiltonian (list or Hamiltonian): 记录哈密顿量信息的列表或 Hamiltonian 类的对象 + shots (int): 测量次数；默认为 0，表示返回期望值的精确值，即测量无穷次后的期望值 + grad_func_name (string, optional): 用来计算梯度的函数的函数名，可以选择 'linear_comb'、'finite_diff' 或 'param_shift'。 + 只有特定需要梯度的 optimizer 如 ``ConjugateGradient`` 需要，默认为 ``None`` + delta (float, optional): 差分法中的 delta，默认为 0.01 + """ + self.cir = cir + self.grad_func_name = grad_func_name + self.hamiltonian = hamiltonian + self.shots = shots + self.delta = delta + self.loss_func = self._get_expec_val_scipy + + self.grad_func = None + if self.grad_func_name == 'linear_comb': + self.grad_func = self._linear_combinations_gradient_scipy + elif self.grad_func_name == 'finite_diff': + self.grad_func = self._finite_difference_gradient_scipy + elif self.grad_func_name == 'param_shift': + self.grad_func = self._param_shift_gradient_scipy + else: + assert self.grad_func_name == None, \ + "grad_func_name should be None or one of 'linear_comb', 'finite_diff', 'param_shift'" + + def _get_expec_val_scipy(self, theta, cir, H, shots=0): + r"""计算关于哈密顿量 H 的期望的理论值。 + + Note: + 这是内部函数，你并不需要直接调用到该函数。 + """ + cir.update_param(theta) + return cir.expecval(H, shots).numpy() + + def _linear_combinations_gradient_scipy(self, theta, cir, H, shots): + r"""用 linear combination 的方法计算参数的梯度。 + + Note: + 这是内部函数，你并不需要直接调用到该函数。 + """ + grad = cir.linear_combinations_gradient(H, shots) + return grad + + def _finite_difference_gradient_scipy(self, theta, cir, H, shots): + r"""用差分法计算参数的梯度。 + + Note: + 这是内部函数，你并不需要直接调用到该函数。 + """ + grad = cir.finite_difference_gradient(H, self.delta, shots) + return grad + + def _param_shift_gradient_scipy(self, theta, cir, H, shots): + r"""用 parameter shift 的方法计算参数的梯度。 + + Note: + 这是内部函数，你并不需要直接调用到该函数。 + """ + grad = cir.param_shift_gradient(H, shots) + return grad + + @abstractmethod + def minimize(self, iterations): + r"""最小化给定的损失函数。 + + Args: + iterations (int): 迭代的次数 + """ + raise NotImplementedError diff --git a/paddle_quantum/optimizer/newton_cg.py b/paddle_quantum/optimizer/newton_cg.py new file mode 100644 index 0000000..c281a75 --- /dev/null +++ b/paddle_quantum/optimizer/newton_cg.py @@ -0,0 +1,62 @@ +# Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +""" +Newton-CG optimizer +""" + +from scipy import optimize +from .custom_optimizer import CustomOptimizer + +class NewtonCG(CustomOptimizer): + r"""Newton-CG Optimizer + + 继承 ``CustomOptimizer`` 类，使用 SciPy 里 Newton conjugate gradient 的方法优化。此优化器需要说明计算梯度的方法。 + + Attributes: + cir (UAnsatz): 带可训练参数的量子电路 + hamiltonian (list or Hamiltonian): 记录哈密顿量信息的列表或 ``Hamiltonian`` 类的对象 + shots (int): 测量次数；默认为 0，表示返回期望值的精确值，即测量无穷次后的期望值 + grad_func_name (string): 用来计算梯度的函数的函数名，可以选择 'linear_comb'、'finite_diff' 或 'param_shift'，默认为 ``None`` + delta (float): 差分法中的 delta，默认为 0.01 + """ + + def __init__(self, cir, hamiltonian, shots, grad_func_name=None, delta=0.01): + r"""``NewtonCG`` 的构造函数。 + + Args: + cir (UAnsatz): 带可训练参数的量子电路 + hamiltonian (list or Hamiltonian): 记录哈密顿量信息的列表或 ``Hamiltonian`` 类的对象 + shots (int): 测量次数；默认为 0，表示返回期望值的精确值，即测量无穷次后的期望值 + grad_func_name (string): 用来计算梯度的函数的函数名，可以选择 'linear_comb'、'finite_diff' 或 'param_shift'，默认为 ``None`` + delta (float): 差分法中的 delta，默认为 0.01 + """ + super().__init__(cir, hamiltonian, shots, grad_func_name, delta) + + def minimize(self, iterations): + r"""最小化给定的损失函数。 + + Args: + iterations (int): 迭代的次数 + """ + opt_res = optimize.minimize( + self.loss_func, + self.cir.get_param().numpy(), + args=(self.cir, self.hamiltonian, self.shots), + method='Newton-CG', + jac=self.grad_func, + options={'maxiter': iterations}, + callback=lambda xk: print('loss: ', (self.loss_func(xk, self.cir, self.hamiltonian, self.shots))) + ) + print(opt_res.message) diff --git a/paddle_quantum/optimizer/powell.py b/paddle_quantum/optimizer/powell.py new file mode 100644 index 0000000..a91dbff --- /dev/null +++ b/paddle_quantum/optimizer/powell.py @@ -0,0 +1,58 @@ +# Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +""" +Powell optimizer +""" + +from scipy import optimize +from .custom_optimizer import CustomOptimizer + +class Powell(CustomOptimizer): + r"""Powell Optimizer + + 继承 ``CustomOptimizer`` 类，使用 SciPy 里 Powell 方法优化。该方法不需要传入计算 gradient 的方式。 + + Attributes: + cir (UAnsatz): 带可训练参数的量子电路 + hamiltonian (list or Hamiltonian): 记录哈密顿量信息的列表或 ``Hamiltonian`` 类的对象 + shots (int): 测量次数；默认为 0，表示返回期望值的精确值，即测量无穷次后的期望值 + """ + + def __init__(self, cir, hamiltonian, shots): + r"""``Powell`` 的构造函数。 + + Args: + cir (UAnsatz): 带可训练参数的量子电路 + hamiltonian (list or Hamiltonian): 记录哈密顿量信息的列表或 ``Hamiltonian`` 类的对象 + shots (int): 测量次数；默认为 0，表示返回期望值的精确值，即测量无穷次后的期望值 + + """ + super().__init__(cir, hamiltonian, shots) + + def minimize(self, iterations): + r"""最小化给定的损失函数。 + + Args: + iterations (int): 迭代的次数 + """ + opt_res = optimize.minimize( + self.loss_func, + self.cir.get_param().numpy(), + args=(self.cir, self.hamiltonian, self.shots), + method='Powell', + options={'maxiter': iterations}, + callback=lambda xk: print('loss: ', self.loss_func(xk, self.cir, self.hamiltonian, self.shots)) + ) + print(opt_res.message) diff --git a/paddle_quantum/optimizer/slsqp.py b/paddle_quantum/optimizer/slsqp.py new file mode 100644 index 0000000..e508cef --- /dev/null +++ b/paddle_quantum/optimizer/slsqp.py @@ -0,0 +1,57 @@ +# Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +""" +SLSQP optimizer +""" + +from scipy import optimize +from .custom_optimizer import CustomOptimizer + +class SLSQP(CustomOptimizer): + r"""SLSQP Optimizer + + 继承 ``CustomOptimizer`` 类，使用 SciPy 里 SLSQP 方法优化。该方法不需要传入计算 gradient 的方式。 + + Attributes: + cir (UAnsatz): 带可训练参数的量子电路 + hamiltonian (list or Hamiltonian): 记录哈密顿量信息的列表或 ``Hamiltonian`` 类的对象 + shots (int): 测量次数；默认为 0，表示返回期望值的精确值，即测量无穷次后的期望值 + """ + + def __init__(self, cir, hamiltonian, shots): + r"""``SLSQP`` 的构造函数。 + + Args: + cir (UAnsatz): 带可训练参数的量子电路 + hamiltonian (list or Hamiltonian): 记录哈密顿量信息的列表或 ``Hamiltonian`` 类的对象 + shots (int): 测量次数；默认为 0，表示返回期望值的精确值，即测量无穷次后的期望值 + """ + super().__init__(cir, hamiltonian, shots) + + def minimize(self, iterations): + r"""最小化给定的损失函数。 + + Args: + iterations (int): 迭代的次数 + """ + opt_res = optimize.minimize( + self.loss_func, + self.cir.get_param().numpy(), + args=(self.cir, self.hamiltonian, self.shots), + method='SLSQP', + options={'maxiter': iterations}, + callback=lambda xk: print('loss: ', self.loss_func(xk, self.cir, self.hamiltonian, self.shots)) + ) + print(opt_res.message) diff --git a/paddle_quantum/shadow.py b/paddle_quantum/shadow.py new file mode 100644 index 0000000..3011255 --- /dev/null +++ b/paddle_quantum/shadow.py @@ -0,0 +1,451 @@ +# Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +""" +shadow sample module +""" + +import numpy as np +import paddle +import re +from paddle_quantum import circuit +from paddle_quantum.utils import Hamiltonian + +__all__ = [ + "shadow_sample" +] + + +def shadow_sample(state, num_qubits, sample_shots, mode, hamiltonian=None, method='CS'): + r"""对给定的量子态进行随机的泡利测量并返回测量结果。 + + Args: + state (numpy.ndarray): 输入量子态，支持态矢量和密度矩阵形式 + num_qubits (int): 量子比特数量 + sample_shots (int): 随机采样的次数 + mode (str): 输入量子态的表示方式，``"state_vector"`` 表示态矢量形式， ``"density_matrix"`` 表示密度矩阵形式 + hamiltonian (Hamiltonian, optional): 可观测量的相关信息，输入形式为 ``Hamiltonian`` 类，默认为 ``None`` + method (str, optional): 进行随机采样的方法，有 ``"CS"`` 、 ``"LBCS"`` 、 ``"APS"`` 三种方法，默认为 ``"CS"`` + + Returns: + list: 随机选择的泡利测量基和测量结果，形状为 ``(sample_shots, 2)`` 的list + + 代码示例: + + .. code-block:: python + from paddle_quantum.shadow import shadow_sample + from paddle_quantum.state import vec_random + from paddle_quantum.utils import Hamiltonian + + n_qubit = 2 + sample_shots = 10 + state = vec_random(n_qubit) + sample_data_cs = shadow_sample(state, n_qubit, sample_shots, mode='state_vector') + + ham = [[0.1, 'x1'], [0.2, 'y0']] + ham = Hamiltonian(ham) + sample_data_lbcs, beta_lbcs = shadow_sample(state, n_qubit, sample_shots, 'state_vector', "LBCS", ham) + sample_data_aps = shadow_sample(state, n_qubit, sample_shots, 'state_vector', "APS", ham) + + print('sample data CS = ', sample_data_cs) + print('sample data LBCS = ', sample_data_lbcs) + print('beta LBCS = ', beta_lbcs) + print('sample data APS = ', sample_data_aps) + + :: + + sample data CS = [('zy', '10'), ('yx', '01'), ('zx', '01'), ('xz', '00'), ('zy', '11'), ('xz', '00'), ('xz', '11'), ('yy', '01'), ('yx', '00'), ('xx', '00')] + sample data LBCS = [('yx', '00'), ('yx', '01'), ('yx', '00'), ('yx', '01'), ('yx', '00'), ('yx', '01'), ('yx', '01'), ('yx', '00'), ('yx', '01'), ('yx', '01')] + beta LBCS = [[2.539244934862217e-05, 0.9999492151013026, 2.539244934862217e-05], [0.9999492151013026, 2.539244934862217e-05, 2.539244934862217e-05]] + sample data APS = [('yx', '10'), ('yx', '01'), ('yx', '00'), ('yx', '01'), ('yx', '10'), ('yx', '01'), ('yx', '10'), ('yx', '10'), ('yx', '00'), ('yx', '01')] + + """ + + if hamiltonian is not None: + if isinstance(hamiltonian, Hamiltonian): + hamiltonian = hamiltonian.pauli_str + + def prepare_hamiltonian(hamiltonian, num_qubits): + r"""改写可观测量[[0.3147,'y2'], [-0.5484158742278,'x2,z1'],...]的形式 + + Args: + hamiltonian (list): 可观测量的相关信息 + num_qubits (int): 量子比特数目 + + Returns: + list: 可观测量的形式改写为[[0.3147,'iiy'], [-0.5484158742278,'izx'],...] + + Note: + 这是内部函数，你并不需要直接调用到该函数。 + """ + new_hamiltonian = list() + for idx, (coeff, pauli_term) in enumerate(hamiltonian): + pauli_term = re.split(r',\s*', pauli_term.lower()) + pauli_list = ['i'] * num_qubits + for item in pauli_term: + if len(item) > 1: + pauli_list[int(item[1:])] = item[0] + elif item[0].lower() != 'i': + raise ValueError('Expecting I for ', item[0]) + new_term = [coeff, ''.join(pauli_list)] + new_hamiltonian.append(new_term) + return new_hamiltonian + + if hamiltonian is not None: + hamiltonian = prepare_hamiltonian(hamiltonian, num_qubits) + + pauli2index = {'x': 0, 'y': 1, 'z': 2} + + def random_pauli_sample(num_qubits, beta=None): + r"""根据概率分布 beta, 随机选取 pauli 测量基 + + Args: + num_qubits (int): 量子比特数目 + beta (list, optional): 量子位上不同 pauli 测量基的概率分布 + + Returns: + str: 返回随机选择的 pauli 测量基 + + Note: + 这是内部函数，你并不需要直接调用到该函数。 + """ + # assume beta obeys a uniform distribution if it is not given + if beta is None: + beta = list() + for _ in range(0, num_qubits): + beta.append([1 / 3] * 3) + pauli_sample = str() + for qubit_idx in range(num_qubits): + sample = np.random.choice(['x', 'y', 'z'], 1, p=beta[qubit_idx]) + pauli_sample += sample[0] + return pauli_sample + + def measure_by_pauli_str(pauli_str, phi, num_qubits, method): + r"""搭建 pauli 测量电路，返回测量结果 + + Args: + pauli_str (str): 输入的是随机选取的num_qubits pauli 测量基 + phi (numpy.ndarray): 输入量子态，支持态矢量和密度矩阵形式 + num_qubits (int): 量子比特数量 + method (str): 进行测量的方法，有 "CS"、"LBCS"、"APS" + + Returns: + str: 返回测量结果 + + Note: + 这是内部函数，你并不需要直接调用到该函数。 + """ + if method == "clifford": + # Add the clifford function + pass + else: + # Other method are transformed as follows + # Convert to tensor form + input_state = paddle.to_tensor(phi) + cir = circuit.UAnsatz(num_qubits) + for qubit in range(num_qubits): + if pauli_str[qubit] == 'x': + cir.h(qubit) + elif pauli_str[qubit] == 'y': + cir.h(qubit) + cir.s(qubit) + cir.h(qubit) + if mode == 'state_vector': + cir.run_state_vector(input_state) + else: + cir.run_density_matrix(input_state) + result = cir.measure(shots=1) + bit_string, = result + return bit_string + + # Define the function used to update the beta of the LBCS algorithm + def calculate_diagonal_product(pauli_str, beta): + r"""迭代 LBCS beta 公式中的一部分 + + Hint: + 计算 \prod_{j \in supp(Q)} \beta_{j}(Q_{j})^{-1} + + Args: + pauli_str (str): 输入的是 hamiltonian 的 pauli 项 + beta (list): 量子位上不同 pauli 测量基的概率分布 + + Returns: + float: 返回计算值 + + Note: + 这是内部函数，你并不需要直接调用到该函数。 + """ + product = 1 + for qubit_idx in range(len(pauli_str)): + if pauli_str[qubit_idx] != 'i': + index = pauli2index[pauli_str[qubit_idx]] + b = beta[qubit_idx][index] + if b == 0: + return float('inf') + else: + product *= b + + return 1 / product + + def lagrange_restriction_numerator(qubit_idx, hamiltonian, beta): + r"""迭代 LBCS beta 公式中的分子 + + Hint: + 计算 \sum_{Q \mid Q_{i}=P_{i}} \alpha_{Q}^{2} \prod_{j \in supp(Q)} \beta_{j}(Q_{j})^{-1} + + Args: + qubit_idx (int): 第 qubit_idx 个量子位 + hamiltonian (list): 可观测量的相关信息 + beta (list): 量子位上不同 pauli 测量基的概率分布 + + Returns: + list: 返回第 qubit_idx 个量子位上不同 pauli 算子的在该式下的数值 + + Note: + 这是内部函数，你并不需要直接调用到该函数。 + """ + tally = [0, 0, 0] + for coeff, pauli_term in hamiltonian: + if pauli_term[qubit_idx] == 'x': + tally[0] += (coeff ** 2) * calculate_diagonal_product(pauli_term, beta) + elif pauli_term[qubit_idx] == 'y': + tally[1] += (coeff ** 2) * calculate_diagonal_product(pauli_term, beta) + elif pauli_term[qubit_idx] == 'z': + tally[2] += (coeff ** 2) * calculate_diagonal_product(pauli_term, beta) + return tally + + def lagrange_restriction_denominator(qubit_idx, random_observable, beta): + r"""迭代 LBCS beta 公式中的分母 + + Hint: + 计算 \sum_{Q \mid Q_{i} \neq I} \alpha_{Q}^{2} \prod_{j \in supp(Q)} \beta_{j}(Q_{j})^{-1} + + Args: + qubit_idx (int): 第 qubit_idx 个量子位 + random_observable (list): 可观测量的相关信息 + beta (list): 量子位上不同 pauli 测量基的概率分布 + + Returns: + float: 返回第 qubit_idx 个量子位上在该式下的数值 + + Note: + 这是内部函数，你并不需要直接调用到该函数。 + """ + tally = 0.0 + for coeff, pauli_term in random_observable: + if pauli_term[qubit_idx] != "i": + tally += (coeff ** 2) * calculate_diagonal_product(pauli_term, beta) + if tally == 0.0: + tally = 1 + return tally + + def lagrange_restriction(qubit_idx, hamiltonian, beta, denominator=None): + r"""迭代 LBCS beta 公式，将分子与分母结合起来 + + Args: + qubit_idx (int): 第 qubit_idx 个量子位 + hamiltonian (list): 可观测量的相关信息 + beta (list): 量子位上不同 pauli 测量基的概率分布 + denominator (float, optional): 迭代公式的分母，可默认为None + + Returns: + list: 返回第 qubit_idx 个量子位上在该式下的数值 + + Note: + 这是内部函数，你并不需要直接调用到该函数。 + """ + numerator = lagrange_restriction_numerator(qubit_idx, hamiltonian, beta) + if denominator is None: + denominator = lagrange_restriction_denominator(qubit_idx, hamiltonian, beta) + return [item / denominator for item in numerator] + + def beta_distance(beta1, beta2): + r"""计算迭代前后 beta 差距，以便停止迭代 + + Args: + beta1 (list): 迭代后的全部量子位上的概率分布 + beta2 (list): 迭代前的全部量子位上的概率分布 + + Returns: + numpy.float: 返回迭代前后 beta 差距 + + Note: + 这是内部函数，你并不需要直接调用到该函数。 + """ + two_norm_squared = 0.0 + for qubit in range(len(beta1)): + two_norm_squared_qubit = np.sum((np.array(beta1[qubit]) - np.array(beta2[qubit])) ** 2) + two_norm_squared += two_norm_squared_qubit + return np.sqrt(two_norm_squared) + + def update_beta_in_lbcs(hamiltonian, num_qubit, beta_old=None, weight=0.1): + r"""LBCS 的 beta 迭代函数 + + Args: + hamiltonian (list): 可观测量的相关信息 + num_qubit (int): 量子比特数 + beta_old (list): 迭代前的全部量子位上的概率分布 + weight (float): 更新的步长，可根据需要修改 + + Returns: + list: 返回更新后的 beta + numpy.float: 返回迭代前后 beta 差距 + + Note: + 这是内部函数，你并不需要直接调用到该函数。 + """ + if beta_old is None: + beta_old = list() + for _ in range(0, num_qubit): + beta_old.append([1 / 3] * 3) + + beta_new = list() + for qubit in range(num_qubit): + denominator = lagrange_restriction_denominator(qubit, hamiltonian, beta_old) + lagrange_rest = lagrange_restriction(qubit, hamiltonian, beta_old, denominator) + beta_new.append(lagrange_rest) + if sum(beta_new[qubit]) != 0: + beta_new[qubit] = [item / sum(beta_new[qubit]) for item in beta_new[qubit]] + else: + beta_new[qubit] = beta_old[qubit] + for idx in range(len(beta_new[qubit])): + beta_new[qubit][idx] = (1 - weight) * beta_old[qubit][idx] + weight * beta_new[qubit][idx] + return beta_new, beta_distance(beta_new, beta_old) + + # Define the function used to update the beta of the APS algorithm + def in_omega(pauli_str, qubit_idx, qubit_shift, base_shift): + r"""用于判断 hamiltonian 的 pauli 项是否属于集合Omega + + Args: + pauli_str (str): 可观测量的 pauli 项 + qubit_idx (int): 第 qubit_idx 量子位 + qubit_shift (list): 乱序重排量子位，比如第1位映射到第4位 + base_shift (float): 乱序排放的 pauli 测量基 + + Note: + 这是内部函数，你并不需要直接调用到该函数。 + """ + if pauli_str[qubit_shift[qubit_idx]] == 'i': + return False + for former_qubit in range(qubit_idx): + idx = qubit_shift[former_qubit] + if not pauli_str[idx] in ('i', base_shift[former_qubit]): + return False + return True + + def update_in_aps(qubit_idx, qubits_shift, bases_shift, hamiltonian): + r"""用于更新 APS 的 beta + + Args: + qubit_idx (int): 第 qubit_idx 量子位 + qubit_shift (list): 乱序重排量子位，比如第1位映射到第4位 + base_shift (float): 乱序排放的 pauli 测量基 + hamiltonian (list): 可观测量的相关信息 + + Returns: + list: 返回更新后的 beta + + Note: + 这是内部函数，你并不需要直接调用到该函数。 + """ + constants = [0.0, 0.0, 0.0] + for coeff, pauli_term in hamiltonian: + if in_omega(pauli_term, qubit_idx, qubits_shift, bases_shift): + pauli = pauli_term[qubits_shift[qubit_idx]] + index = pauli2index[pauli] + constants[index] += coeff ** 2 + beta_sqrt = np.sqrt(constants) + # The beta may be zero, use a judgment statement to avoid + if np.sum(beta_sqrt) == 0.0: + beta = [1 / 3, 1 / 3, 1 / 3] + else: + beta = beta_sqrt / np.sum(beta_sqrt) + return beta + + def single_random_pauli_sample_in_aps(qubit_idx, qubits_shift, pauli_str_shift, hamiltonian): + r"""用于在单量子位上根据概率分布随机选取 pauli 测量基 + + Args: + qubit_idx (int): 第 qubit_idx 量子位 + qubit_shift (list): 乱序重排量子位，比如第1位映射到第4位 + base_shift (float): 乱序排放的 pauli 测量基 + hamiltonian (list): 可观测量的相关信息 + + Returns: + str: 返回在第 qubit_idx 量子位上选取的 pauli 测量基 + + Note: + 这是内部函数，你并不需要直接调用到该函数。 + """ + assert len(pauli_str_shift) == qubit_idx + beta = update_in_aps(qubit_idx, qubits_shift, pauli_str_shift, hamiltonian) + single_pauli = np.random.choice(['x', 'y', 'z'], p=beta) + return single_pauli + + def random_pauli_sample_in_aps(hamiltonian): + r"""用于根据概率分布随机选择所有量子位上的 pauli 测量基 + + Args: + hamiltonian (list): 可观测量的相关信息 + + Returns: + list: 返回所有量子位上随机选择的 pauli 测量基 + + Note: + 这是内部函数，你并不需要直接调用到该函数。 + """ + num_qubits = len(hamiltonian[0][1]) + # The qubits_shift is used to ignore the order of the qubits + qubits_shift = list(np.random.choice(range(num_qubits), size=num_qubits, replace=False)) + pauli_str_shift = list() + for qubit_idx in range(num_qubits): + single_pauli = single_random_pauli_sample_in_aps(qubit_idx, qubits_shift, pauli_str_shift, hamiltonian) + pauli_str_shift.append(single_pauli) + pauli_sample = str() + for i in range(num_qubits): + j = qubits_shift.index(i) + # The qubits_shift.index(i) sorts the qubits in order + pauli_sample = pauli_sample + pauli_str_shift[j] + return pauli_sample + + sample_result = list() + if method == "CS": + for _ in range(sample_shots): + random_pauli_str = random_pauli_sample(num_qubits, beta=None) + measurement_result = measure_by_pauli_str(random_pauli_str, state, num_qubits, method) + sample_result.append((random_pauli_str, measurement_result)) + return sample_result + elif method == "LBCS": + beta = list() + for _ in range(0, num_qubits): + beta.append([1 / 3] * 3) + beta_opt_iter_num = 10000 + distance_limit = 1.0e-6 + for _ in range(beta_opt_iter_num): + beta_opt, distance = update_beta_in_lbcs(hamiltonian, num_qubits, beta) + beta = beta_opt + if distance < distance_limit: + break + sample_result = list() + for _ in range(sample_shots): + random_pauli_str = random_pauli_sample(num_qubits, beta) + measurement_result = measure_by_pauli_str(random_pauli_str, state, num_qubits, method) + sample_result.append((random_pauli_str, measurement_result)) + return sample_result, beta + elif method == "APS": + for _ in range(sample_shots): + random_pauli_str = random_pauli_sample_in_aps(hamiltonian) + measurement_result = measure_by_pauli_str(random_pauli_str, state, num_qubits, method) + sample_result.append((random_pauli_str, measurement_result)) + return sample_result diff --git a/paddle_quantum/simulator.py b/paddle_quantum/simulator.py index ca88b23..09b8d88 100644 --- a/paddle_quantum/simulator.py +++ b/paddle_quantum/simulator.py @@ -186,6 +186,50 @@ def u_gate_matrix(params): # paddle.to_tensor(np.array([3.0]))]) # print(a.numpy()) +def cu_gate_matrix(params): + """ + Control U3 + :return: + """ + theta, phi, lam = params + + if (type(theta) is paddle.Tensor and + type(phi) is paddle.Tensor and + type(lam) is paddle.Tensor): + re_a = paddle.cos(theta / 2) + re_b = - paddle.cos(lam) * paddle.sin(theta / 2) + re_c = paddle.cos(phi) * paddle.sin(theta / 2) + re_d = paddle.cos(phi + lam) * paddle.cos(theta / 2) + im_a = paddle.zeros([1], 'float64') + im_b = - paddle.sin(lam) * paddle.sin(theta / 2) + im_c = paddle.sin(phi) * paddle.sin(theta / 2) + im_d = paddle.sin(phi + lam) * paddle.cos(theta / 2) + + re = paddle.reshape(paddle.concat([re_a, re_b, re_c, re_d]), [2, 2]) + im = paddle.reshape(paddle.concat([im_a, im_b, im_c, im_d]), [2, 2]) + + id = paddle.eye(2, dtype='float64') + z2 = paddle.zeros(shape=[2,2], dtype='float64') + + re = paddle.concat([paddle.concat([id, z2], -1), paddle.concat([z2, re], -1)]) + im = paddle.concat([paddle.concat([z2, z2], -1), paddle.concat([z2, im], -1)]) + + return re + im * paddle.to_tensor([1j], 'complex128') + + elif (type(theta) is float and + type(phi) is float and + type(lam) is float): + u3 = np.array([[np.cos(theta / 2), + -np.exp(1j * lam) * np.sin(theta / 2)], + [np.exp(1j * phi) * np.sin(theta / 2), + np.exp(1j * phi + 1j * lam) * np.cos(theta / 2)]]) + return np.block([ + [np.eye(2, dtype=float), np.zeros((2, 2), dtype=float)], [np.zeros((2, 2), dtype=float), u3] + ]).reshape((2,2,2,2)) + + else: + assert False + def cx_gate_matrix(): """ @@ -198,6 +242,28 @@ def cx_gate_matrix(): [0, 0, 1, 0]], dtype=complex).reshape((2, 2, 2, 2)) +def cy_gate_matrix(): + """ + Control Y + :return: + """ + return np.array([[1, 0, 0, 0], + [0, 1, 0, 0], + [0, 0, 0, -1j], + [0, 0, 1j, 0]], dtype=complex).reshape((2, 2, 2, 2)) + + +def cz_gate_matrix(): + """ + Control Z + :return: + """ + return np.array([[1, 0, 0, 0], + [0, 1, 0, 0], + [0, 0, 1, 0], + [0, 0, 0, -1]], dtype=complex).reshape((2, 2, 2, 2)) + + def swap_gate_matrix(): """ Swap gate @@ -214,7 +280,7 @@ def rxx_gate_matrix(params): RXX gate :return: """ - theta = params + theta = params[0] re_a = paddle.cos(theta / 2) re_b = paddle.zeros([1], 'float64') im_a = paddle.sin(theta / 2) @@ -236,7 +302,7 @@ def ryy_gate_matrix(params): RYY gate :return: """ - theta = params + theta = params[0] re_a = paddle.cos(theta / 2) re_b = paddle.zeros([1], 'float64') im_a = paddle.sin(theta / 2) @@ -258,7 +324,7 @@ def rzz_gate_matrix(params): RZZ gate :return: """ - theta = params + theta = params[0] re_a = paddle.cos(theta / 2) re_b = paddle.zeros([1], 'float64') im_a = paddle.sin(theta / 2) @@ -274,6 +340,7 @@ def rzz_gate_matrix(params): return re + im * paddle.to_tensor([1j], 'complex128') + # PaddleE def normalize_axis(axis, ndim): if axis < 0: @@ -366,6 +433,86 @@ def complex_moveaxis(m, source, destination): # # return m +def get_cswap_state(state, bits): + """ + Transfer to the next state after applying CSWAP gate + :param state: + :param bits: + :return: + """ + q0 = bits[0] + q1 = bits[1] + q2 = bits[2] + + # helper angles + theta0 = paddle.to_tensor(np.array([0.0])) + thetan2 = paddle.to_tensor(np.array([-np.pi / 2], np.float64)) + theta2 = paddle.to_tensor(np.array([np.pi / 2], np.float64)) + thetan4 = paddle.to_tensor(np.array([-np.pi / 4], np.float64)) + theta4 = paddle.to_tensor(np.array([np.pi / 4], np.float64)) + + # implements cswap gate using cnot and Single-qubit gates + state = transfer_state(state, cx_gate_matrix(), [q2, q1]) + state = transfer_state(state, u_gate_matrix([thetan2, theta0, theta0]), [q2]) # ry + state = transfer_state(state, u_gate_matrix([theta0, theta0, theta4]), [q0]) # rz + state = transfer_state(state, u_gate_matrix([theta0, theta0, theta4]), [q1]) # rz + state = transfer_state(state, u_gate_matrix([theta0, theta0, theta4]), [q2]) # rz + state = transfer_state(state, cx_gate_matrix(), [q0, q1]) + state = transfer_state(state, cx_gate_matrix(), [q1, q2]) + state = transfer_state(state, u_gate_matrix([theta0, theta0, thetan4]), [q1]) # rz + state = transfer_state(state, u_gate_matrix([theta0, theta0, theta4]), [q2]) # rz + state = transfer_state(state, cx_gate_matrix(), [q0, q1]) + state = transfer_state(state, cx_gate_matrix(), [q1, q2]) + state = transfer_state(state, cx_gate_matrix(), [q0, q1]) + state = transfer_state(state, u_gate_matrix([theta0, theta0, thetan4]), [q2]) # rz + state = transfer_state(state, cx_gate_matrix(), [q1, q2]) + state = transfer_state(state, u_gate_matrix([theta2, thetan2, theta2]), [q1]) # rx + state = transfer_state(state, u_gate_matrix([theta0, theta0, thetan4]), [q2]) # rz + state = transfer_state(state, cx_gate_matrix(), [q0, q1]) + state = transfer_state(state, cx_gate_matrix(), [q1, q2]) + state = transfer_state(state, u_gate_matrix([theta0, theta0, theta2]), [q2]) # rz + state = transfer_state(state, u_gate_matrix([theta2, thetan2, theta2]), [q1]) # rx + state = transfer_state(state, u_gate_matrix([thetan2, thetan2, theta2]), [q2]) # rx + + return state + + +def get_ccx_state(state, bits): + """ + Transfer to the next state after applying CCX gate + :param state: + :param bits: + :return: + """ + q0 = bits[0] + q1 = bits[1] + q2 = bits[2] + + # helper angles + theta0 = paddle.to_tensor(np.array([0.0])) + theta2 = paddle.to_tensor(np.array([np.pi / 2], np.float64)) + thetan4 = paddle.to_tensor(np.array([-np.pi / 4], np.float64)) + theta4 = paddle.to_tensor(np.array([np.pi / 4], np.float64)) + + # implements ccx gate using cnot and Single-qubit gates + state = transfer_state(state, h_gate_matrix(), [q2]) #h + state = transfer_state(state, cx_gate_matrix(), [q1, q2]) # cx + state = transfer_state(state, u_gate_matrix([theta0, theta0, thetan4]), [q2]) # tdagger + state = transfer_state(state, cx_gate_matrix(), [q0, q2]) #cx + state = transfer_state(state, u_gate_matrix([theta0, theta0, theta4]), [q2]) # t + state = transfer_state(state, cx_gate_matrix(), [q1, q2]) #cx + state = transfer_state(state, u_gate_matrix([theta0, theta0, thetan4]), [q2]) # tdagger + state = transfer_state(state, cx_gate_matrix(), [q0, q2]) # cx + state = transfer_state(state, u_gate_matrix([theta0, theta0, thetan4]), [q1]) # tdagger + state = transfer_state(state, u_gate_matrix([theta0, theta0, theta4]), [q2]) # t + state = transfer_state(state, h_gate_matrix(), [q2]) # h + state = transfer_state(state, cx_gate_matrix(), [q0, q1]) #cx + state = transfer_state(state, u_gate_matrix([theta0, theta0, thetan4]), [q1]) # tdagger + state = transfer_state(state, cx_gate_matrix(), [q0, q1]) #cx + state = transfer_state(state, u_gate_matrix([theta0, theta0, theta4]), [q0]) # t + state = transfer_state(state, u_gate_matrix([theta0, theta0, theta2]), [q1]) # s + return state + # TransferProcess def transfer_state(state, gate_matrix, bits): @@ -394,8 +541,10 @@ def transfer_state(state, gate_matrix, bits): # compressed moveaxis # compress the continuous dim before moveaxis - # e.g. single operand: before moveaxis 2*2*[2]*2*2 -compress-> 4*[2]*4, after moveaxis [2]*2*2*2*2 -compress-> [2]*4*4 - # double operands: before moveaxis 2*2*[2]*2*2*[2]*2*2 -compress-> 4*[2]*4*[2]*4, after moveaxis [2]*[2]*2*2*2*2*2*2 -compress-> [2]*[2]*4*4*4 + # e.g. single operand: before moveaxis 2*2*[2]*2*2 -compress-> 4*[2]*4, + # after moveaxis [2]*2*2*2*2 -compress-> [2]*4*4 + # double operands: before moveaxis 2*2*[2]*2*2*[2]*2*2 -compress-> 4*[2]*4*[2]*4, + # after moveaxis [2]*[2]*2*2*2*2*2*2 -compress-> [2]*[2]*4*4*4 # the peak rank is 5 when the number of operands is 2 assert len(source_pos) == 1 or len(source_pos) == 2 compressed_shape_before_moveaxis = [1] @@ -469,6 +618,15 @@ def StateTransfer(state, gate_name, bits, params=None): elif gate_name == 'CNOT': # print('----------', gate_name, bits, '----------') gate_matrix = cx_gate_matrix() + elif gate_name == 'CU': + # print('----------', gate_name, bits, '----------') + gate_matrix = cu_gate_matrix(params) + elif gate_name == 'cy': + # print('----------', gate_name, bits, '----------') + gate_matrix = cy_gate_matrix() + elif gate_name == 'cz': + # print('----------', gate_name, bits, '----------') + gate_matrix = cz_gate_matrix() elif gate_name == 'SWAP': # print('----------', gate_name, bits, '----------') gate_matrix = swap_gate_matrix() @@ -484,6 +642,14 @@ def StateTransfer(state, gate_name, bits, params=None): elif gate_name == 'RZZ_gate': # print('----------', gate_name, bits, '----------') gate_matrix = rzz_gate_matrix(params) + elif gate_name == 'CSWAP': + # print('----------', gate_name, bits, '----------') + state = get_cswap_state(state, bits) + return state + elif gate_name == 'CCX': + # print('----------', gate_name, bits, '----------') + state = get_ccx_state(state, bits) + return state else: raise Exception("Gate name error") diff --git a/paddle_quantum/state.py b/paddle_quantum/state.py index d2d98bc..3a3cd4f 100644 --- a/paddle_quantum/state.py +++ b/paddle_quantum/state.py @@ -13,7 +13,6 @@ # limitations under the License. import numpy as np -from numpy import concatenate from numpy import trace as np_trace from numpy import matmul as np_matmul from numpy import random as np_random @@ -36,29 +35,32 @@ __all__ = [ ] -def vec(n): - r"""生成量子态 :math:`|00...0\rangle` 的numpy形式。 +def vec(i, n): + r"""生成计算基态 :math:`|e_{i}\rangle` 的 numpy 形式，其中 :math:`|e_{i}\rangle` 的第 :math:`i` 个元素为 1，其余元素为 0。 Args: - n(int): 量子比特数量 + i(int): 计算基态 :math`|e_{i}\rangle` 的下标 :math:`i` + n(int): 生成的量子态的量子比特数量 Returns: - numpy.ndarray: 一个形状为 ``(1, 2**n)`` 的numpy数组 ``[[1, 0, 0, ..., 0]]`` + numpy.ndarray: 计算基态 :math:`|e_{i}\rangle` 的态矢量形式。 代码示例: .. code-block:: python - + from paddle_quantum.state import vec - vector = vec(3) + vector = vec(1, 3) print(vector) :: - [[1.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j]] + [[0.+0.j 1.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j]] """ assert n > 0, 'qubit number must be larger than 1' - state = concatenate(([[1.0]], np_zeros([1, (2 ** n) - 1])), axis=1) + assert 0 <= i <= 2 ** n - 1, 'i should >= 0 and < 2**n (the dimension of the Hilbert space)' + state = np_zeros([1, 2 ** n]) + state[0][i] = 1 return state.astype("complex128") diff --git a/paddle_quantum/utils.py b/paddle_quantum/utils.py index 2b18716..2e23ff1 100644 --- a/paddle_quantum/utils.py +++ b/paddle_quantum/utils.py @@ -14,7 +14,14 @@ from functools import reduce from math import log2 +from math import sqrt +import os.path +import copy +import re import numpy as np +from scipy.linalg import logm, sqrtm +from matplotlib import colors as mplcolors +import matplotlib.pyplot as plt import paddle from paddle import add, to_tensor from paddle import kron as kron @@ -23,6 +30,12 @@ from paddle import transpose from paddle import concat, ones from paddle import zeros from scipy.linalg import logm, sqrtm +from scipy import sparse +import matplotlib.pyplot as plt +import matplotlib as mpl +from math import sqrt +from paddle_quantum import simulator +import matplotlib.animation as animation __all__ = [ "partial_trace", @@ -39,7 +52,10 @@ __all__ = [ "partial_transpose", "negativity", "logarithmic_negativity", - "is_ppt" + "is_ppt", + "Hamiltonian", + "plot_state_in_bloch_sphere", + "plot_rotation_in_bloch_sphere", ] @@ -100,7 +116,7 @@ def partial_trace_discontiguous(rho, preserve_qubits=None): shape = paddle.ones((n + 1,)) shape = 2 * shape - shape[n] = 2**n + shape[n] = 2 ** n shape = paddle.cast(shape, "int32") identity = paddle.eye(2 ** n) identity = paddle.reshape(identity, shape=shape) @@ -117,7 +133,7 @@ def partial_trace_discontiguous(rho, preserve_qubits=None): permute = paddle.concat([discard, preserve_qubits, addition]) identity = paddle.transpose(identity, perm=permute) - identity = paddle.reshape(identity, (2**n, 2**n)) + identity = paddle.reshape(identity, (2 ** n, 2 ** n)) result = np.zeros((2 ** num_preserve, 2 ** num_preserve), dtype="complex64") result = paddle.to_tensor(result) @@ -166,8 +182,8 @@ def gate_fidelity(U, V): """ assert U.shape == V.shape, 'The shape of two unitary matrices are different' dim = U.shape[0] - fidelity = np.absolute(np.trace(np.matmul(U, V.conj().T)))/dim - + fidelity = np.absolute(np.trace(np.matmul(U, V.conj().T))) / dim + return fidelity @@ -185,9 +201,9 @@ def purity(rho): float: 输入的量子态的纯度 """ gamma = np.trace(np.matmul(rho, rho)) - + return gamma.real - + def von_neumann_entropy(rho): r"""计算量子态的冯诺依曼熵。 @@ -203,8 +219,8 @@ def von_neumann_entropy(rho): float: 输入的量子态的冯诺依曼熵 """ rho_eigenvalue, _ = np.linalg.eig(rho) - entropy = -np.sum(rho_eigenvalue*np.log(rho_eigenvalue)) - + entropy = -np.sum(rho_eigenvalue * np.log(rho_eigenvalue)) + return entropy.real @@ -296,12 +312,12 @@ def random_pauli_str_generator(n, terms=3): list: 随机生成的可观测量的列表形式 """ pauli_str = [] - for sublen in np.random.randint(1, high=n+1, size=terms): + for sublen in np.random.randint(1, high=n + 1, size=terms): # Tips: -1 <= coeff < 1 - coeff = np.random.rand()*2-1 + coeff = np.random.rand() * 2 - 1 ops = np.random.choice(['x', 'y', 'z'], size=sublen) pos = np.random.choice(range(n), size=sublen, replace=False) - op_list = [ops[i]+str(pos[i]) for i in range(sublen)] + op_list = [ops[i] + str(pos[i]) for i in range(sublen)] pauli_str.append([coeff, ','.join(op_list)]) return pauli_str @@ -326,12 +342,15 @@ def pauli_str_to_matrix(pauli_str, n): # Parse pauli_str; 'x0,z1,y4' to 'xziiy' new_pauli_str = [] for coeff, op_str in pauli_str: - init = list('i'*n) - op_list = op_str.split(',') + init = list('i' * n) + op_list = re.split(r',\s*', op_str.lower()) for op in op_list: - pos = int(op[1:]) - assert pos < n, 'n is too small' - init[pos] = op[0] + if len(op) > 1: + pos = int(op[1:]) + assert pos < n, 'n is too small' + init[pos] = op[0] + elif op.lower() != 'i': + raise ValueError('Only Pauli operator "I" can be accepted without specifying its position') new_pauli_str.append([coeff, ''.join(init)]) # Convert new_pauli_str to matrix; 'xziiy' to NKron(x, z, i, i, y) @@ -339,7 +358,7 @@ def pauli_str_to_matrix(pauli_str, n): for coeff, op_str in new_pauli_str: sub_matrices = [] for op in op_str: - sub_matrices.append(pauli_dict[op]) + sub_matrices.append(pauli_dict[op.lower()]) if len(op_str) == 1: matrices.append(coeff * sub_matrices[0]) else: @@ -380,7 +399,7 @@ def partial_transpose_2(density_op, sub_system=None): if sys_idx == 2: for j in [0, 2]: for i in [0, 2]: - transposed_density_op[i:i+2, j:j+2] = density_op[i:i+2, j:j+2].transpose() + transposed_density_op[i:i + 2, j:j + 2] = density_op[i:i + 2, j:j + 2].transpose() else: transposed_density_op[2:4, 0:2] = density_op[0:2, 2:4] transposed_density_op[0:2, 2:4] = density_op[2:4, 0:2] @@ -400,9 +419,9 @@ def partial_transpose(density_op, n): # Copy the density matrix and not corrupt the original one transposed_density_op = np.copy(density_op) - for j in range(0, 2**n, 2): - for i in range(0, 2**n, 2): - transposed_density_op[i:i+2, j:j+2] = density_op[i:i+2, j:j+2].transpose() + for j in range(0, 2 ** n, 2): + for i in range(0, 2 ** n, 2): + transposed_density_op[i:i + 2, j:j + 2] = density_op[i:i + 2, j:j + 2].transpose() return transposed_density_op @@ -467,7 +486,7 @@ def logarithmic_negativity(density_op): n = negativity(density_op) # Calculate through the equivalent expression - log2_n = np.log2(2*n + 1) + log2_n = np.log2(2 * n + 1) return log2_n @@ -499,4 +518,823 @@ def is_ppt(density_op): # Detect negative eigenvalues from the partial transposed density_op if negativity(density_op) > 0: ppt = False - return ppt \ No newline at end of file + return ppt + + +class Hamiltonian: + r""" Paddle Quantum 中的 Hamiltonian ``class``。 + + 用户可以通过一个 Pauli string 来实例化该 ``class``。 + """ + def __init__(self, pauli_str, compress=True): + r""" 创建一个 Hamiltonian 类。 + + Args: + pauli_str (list): 用列表定义的 Hamiltonian，如 ``[(1, 'Z0, Z1'), (2, 'I')]`` + compress (bool): 是否对输入的 list 进行自动合并（例如 ``(1, 'Z0, Z1')`` 和 ``(2, 'Z1, Z0')`` 这两项将被自动合并），默认为 ``True`` + + Note: + 如果设置 ``compress=False``，则不会对输入的合法性进行检验。 + """ + self.__coefficients = None + self.__terms = None + self.__pauli_words_r = [] + self.__pauli_words = [] + self.__sites = [] + self.__nqubits = None + # when internally updating the __pauli_str, be sure to set __update_flag to True + self.__pauli_str = pauli_str + self.__update_flag = True + self.__decompose() + if compress: + self.__compress() + + def __getitem__(self, indices): + new_pauli_str = [] + if isinstance(indices, int): + indices = [indices] + elif isinstance(indices, slice): + indices = list(range(self.n_terms)[indices]) + elif isinstance(indices, tuple): + indices = list(indices) + + for index in indices: + new_pauli_str.append([self.coefficients[index], ','.join(self.terms[index])]) + return Hamiltonian(new_pauli_str, compress=False) + + def __add__(self, h_2): + new_pauli_str = self.pauli_str.copy() + if isinstance(h_2, float) or isinstance(h_2, int): + new_pauli_str.extend([[float(h_2), 'I']]) + else: + new_pauli_str.extend(h_2.pauli_str) + return Hamiltonian(new_pauli_str) + + def __mul__(self, other): + new_pauli_str = copy.deepcopy(self.pauli_str) + for i in range(len(new_pauli_str)): + new_pauli_str[i][0] *= other + return Hamiltonian(new_pauli_str, compress=False) + + def __sub__(self, other): + return self.__add__(other.__mul__(-1)) + + def __str__(self): + str_out = '' + for idx in range(self.n_terms): + str_out += '{} '.format(self.coefficients[idx]) + for _ in range(len(self.terms[idx])): + str_out += self.terms[idx][_] + if _ != len(self.terms[idx]) - 1: + str_out += ', ' + if idx != self.n_terms - 1: + str_out += '\n' + return str_out + + def __repr__(self): + return 'paddle_quantum.Hamiltonian object: \n' + self.__str__() + + @property + def n_terms(self): + r"""返回该哈密顿量的项数 + + Returns: + int :哈密顿量的项数 + """ + return len(self.__pauli_str) + + @property + def pauli_str(self): + r"""返回哈密顿量对应的 Pauli string + + Returns: + list : 哈密顿量对应的 Pauli string + """ + return self.__pauli_str + + @property + def terms(self): + r"""返回哈密顿量中的每一项构成的列表 + + Returns: + list :哈密顿量中的每一项，i.e. ``[['Z0, Z1'], ['I']]`` + """ + if self.__update_flag: + self.__decompose() + return self.__terms + else: + return self.__terms + + @property + def coefficients(self): + r""" 返回哈密顿量中的每一项对应的系数构成的列表 + + Returns: + list :哈密顿量中每一项的系数，i.e.``[1.0, 2.0]`` + """ + if self.__update_flag: + self.__decompose() + return self.__coefficients + else: + return self.__coefficients + + @property + def pauli_words(self): + r"""返回哈密顿量中每一项对应的 Pauli word 构成的列表 + + Returns: + list :每一项对应的 Pauli word，i.e. ``['ZIZ', 'IIX']`` + """ + if self.__update_flag: + self.__decompose() + return self.__pauli_words + else: + return self.__pauli_words + + @property + def pauli_words_r(self): + r"""返回哈密顿量中每一项对应的简化（不包含 I） Pauli word 组成的列表 + + Returns: + list :不包含 "I" 的 Pauli word 构成的列表，i.e. ``['ZXZZ', 'Z', 'X']`` + """ + if self.__update_flag: + self.__decompose() + return self.__pauli_words_r + else: + return self.__pauli_words_r + + @property + def sites(self): + r"""返回该哈密顿量中的每一项对应的量子比特编号组成的列表 + + Returns: + list :哈密顿量中每一项所对应的量子比特编号构成的列表，i.e. ``[[1, 2], [0]]`` + """ + if self.__update_flag: + self.__decompose() + return self.__sites + else: + return self.__sites + + @property + def n_qubits(self): + r"""返回该哈密顿量对应的量子比特数 + + Returns: + int :量子比特数 + """ + if self.__update_flag: + self.__decompose() + return self.__nqubits + else: + return self.__nqubits + + def __decompose(self): + r"""将哈密顿量分解为不同的形式 + + Notes: + 这是一个内部函数，你不需要直接使用它 + 这是一个比较基础的函数，它负责将输入的 Pauli string 拆分为不同的形式并存储在内部变量中 + """ + self.__pauli_words = [] + self.__pauli_words_r = [] + self.__sites = [] + self.__terms = [] + self.__coefficients = [] + self.__nqubits = 1 + new_pauli_str = [] + for coefficient, pauli_term in self.__pauli_str: + pauli_word_r = '' + site = [] + single_pauli_terms = re.split(r',\s*', pauli_term.upper()) + self.__coefficients.append(float(coefficient)) + self.__terms.append(single_pauli_terms) + for single_pauli_term in single_pauli_terms: + match_I = re.match(r'I', single_pauli_term, flags=re.I) + if match_I: + assert single_pauli_term[0].upper() == 'I', \ + 'The offset is defined with a sole letter "I", i.e. (3.0, "I")' + pauli_word_r += 'I' + site.append('') + else: + match = re.match(r'([XYZ])([0-9]+)', single_pauli_term, flags=re.I) + if match: + pauli_word_r += match.group(1).upper() + assert int(match.group(2)) not in site, 'each Pauli operator should act on different qubit' + site.append(int(match.group(2))) + else: + raise Exception( + 'Operators should be defined with a string composed of Pauli operators followed' + + 'by qubit index on which it act, separated with ",". i.e. "Z0, X1"') + self.__nqubits = max(self.__nqubits, int(match.group(2)) + 1) + self.__pauli_words_r.append(pauli_word_r) + self.__sites.append(site) + new_pauli_str.append([float(coefficient), pauli_term.upper()]) + + for term_index in range(len(self.__pauli_str)): + pauli_word = ['I' for _ in range(self.__nqubits)] + site = self.__sites[term_index] + for site_index in range(len(site)): + if type(site[site_index]) == int: + pauli_word[site[site_index]] = self.__pauli_words_r[term_index][site_index] + self.__pauli_words.append(''.join(pauli_word)) + self.__pauli_str = new_pauli_str + self.__update_flag = False + + def __compress(self): + r""" 对同类项进行合并。 + + Notes: + 这是一个内部函数，你不需要直接使用它 + """ + if self.__update_flag: + self.__decompose() + else: + pass + new_pauli_str = [] + flag_merged = [False for _ in range(self.n_terms)] + for term_idx_1 in range(self.n_terms): + if not flag_merged[term_idx_1]: + for term_idx_2 in range(term_idx_1 + 1, self.n_terms): + if not flag_merged[term_idx_2]: + if self.pauli_words[term_idx_1] == self.pauli_words[term_idx_2]: + self.__coefficients[term_idx_1] += self.__coefficients[term_idx_2] + flag_merged[term_idx_2] = True + else: + pass + if self.__coefficients[term_idx_1] != 0: + new_pauli_str.append([self.__coefficients[term_idx_1], ','.join(self.__terms[term_idx_1])]) + self.__pauli_str = new_pauli_str + self.__update_flag = True + + def decompose_with_sites(self): + r"""将 pauli_str 分解为系数，泡利字符串的简化形式，以及它们分别作用的量子比特下标 + + Returns: + tuple: 包含如下元素的 tuple + coefficients (list): 元素为每一项的系数 + pauli_words_r (list): 元素为每一项的泡利字符串的简化形式，例如 'Z0, Z1, X3' 这一项的泡利字符串为 'ZZX' + sites (list): 元素为每一项作用的量子比特下标，例如 'Z0, Z1, X3' 这一项的 site 为 [0, 1, 3] + """ + if self.__update_flag: + self.__decompose() + return self.coefficients, self.__pauli_words_r, self.__sites + + def decompose_pauli_words(self): + r"""将 pauli_str 分解为系数，泡利字符串，以及它们分别作用的量子比特下标 + + Returns: + tuple: 包含如下元素的 tuple + coefficients(list): 元素为每一项的系数 + pauli_words(list): 元素为每一项的泡利字符串，例如 'Z0, Z1, X3' 这一项的泡利字符串为 'ZZIX' + """ + if self.__update_flag: + self.__decompose() + else: + pass + return self.coefficients, self.__pauli_words + + def construct_h_matrix(self): + r"""构建 Hamiltonian 在 Z 基底下的矩阵 + + Returns: + np.ndarray: Z 基底下的哈密顿量矩阵形式 + """ + coefs, pauli_words, sites = self.decompose_with_sites() + n_qubit = 1 + for site in sites: + if type(site[0]) is int: + n_qubit = max(n_qubit, max(site) + 1) + h_matrix = np.zeros([2 ** n_qubit, 2 ** n_qubit], dtype='complex64') + spin_ops = SpinOps(n_qubit, use_sparse=True) + for idx in range(len(coefs)): + op = coefs[idx] * sparse.eye(2 ** n_qubit, dtype='complex64') + for site_idx in range(len(sites[idx])): + if re.match(r'X', pauli_words[idx][site_idx], re.I): + op = op.dot(spin_ops.sigx_p[sites[idx][site_idx]]) + elif re.match(r'Y', pauli_words[idx][site_idx], re.I): + op = op.dot(spin_ops.sigy_p[sites[idx][site_idx]]) + elif re.match(r'Z', pauli_words[idx][site_idx], re.I): + op = op.dot(spin_ops.sigz_p[sites[idx][site_idx]]) + h_matrix += op + return h_matrix + + +class SpinOps: + r"""矩阵表示下的自旋算符，可以用来构建哈密顿量矩阵。 + + """ + def __init__(self, size: int, use_sparse=False): + r"""SpinOps 的构造函数，用于实例化一个 SpinOps 对象 + + Args: + size (int): 系统的大小（有几个量子比特） + use_sparse (bool): 是否使用 sparse matrix 计算，默认为 True + """ + self.size = size + self.id = sparse.eye(2, dtype='complex128') + self.sigz = sparse.bsr.bsr_matrix([[1, 0], [0, -1]], dtype='complex64') + self.sigy = sparse.bsr.bsr_matrix([[0, -1j], [1j, 0]], dtype='complex64') + self.sigx = sparse.bsr.bsr_matrix([[0, 1], [1, 0]], dtype='complex64') + self.sigz_p = [] + self.sigy_p = [] + self.sigx_p = [] + self.__sparse = use_sparse + for i in range(self.size): + self.sigz_p.append(self.__direct_prod_op(spin_op=self.sigz, spin_index=i)) + self.sigy_p.append(self.__direct_prod_op(spin_op=self.sigy, spin_index=i)) + self.sigx_p.append(self.__direct_prod_op(spin_op=self.sigx, spin_index=i)) + + def __direct_prod_op(self, spin_op, spin_index): + r"""直积，得到第 n 个自旋（量子比特）上的自旋算符 + + Args: + spin_op: 单体自旋算符 + spin_index: 标记第 n 个自旋（量子比特） + + Returns: + scipy.sparse or np.ndarray: 直积后的自旋算符，其数据类型取决于 self.__use_sparse + """ + s_p = copy.copy(spin_op) + for i in range(self.size): + if i < spin_index: + s_p = sparse.kron(self.id, s_p) + elif i > spin_index: + s_p = sparse.kron(s_p, self.id) + if self.__sparse: + return s_p + else: + return s_p.toarray() + + +def __input_args_dtype_check( + show_arrow, + save_gif, + filename, + view_angle, + view_dist +): + r""" + 该函数实现对输入默认参数的数据类型检查，保证输入函数中的参数为所允许的数据类型 + + Args: + show_arrow (bool): 是否展示向量的箭头，默认为False + save_gif (bool): 是否存储gif动图，默认10帧，3帧长出bloch向量，7帧转动bloch视角 + filename (str): 存储的gif动图的名字。 + view_angle (list or tuple): 视图的角度，list内第一个元素为关于xy平面的夹角[0-360],第二个元素为关于xz平面的夹角[0-360] + view_dist (int): 视图的距离，默认为7 + """ + + if show_arrow is not None: + assert type(show_arrow) == bool, \ + 'the type of show_arrow should be "bool"' + if save_gif is not None: + assert type(save_gif) == bool, \ + 'the type of save_gif should be "bool"' + if save_gif: + if filename is not None: + assert type(filename) == str, \ + 'the type of filename should be "str"' + other, ext = os.path.splitext(filename) + assert ext == '.gif', 'The suffix of the file name must be "gif"' + # If it does not exist, create a folder + path, file = os.path.split(filename) + if not os.path.exists(path): + os.makedirs(path) + if view_angle is not None: + assert type(view_angle) == list or type(view_angle) == tuple, \ + 'the type of view_angle should be "list" or "tuple"' + for i in range(2): + assert type(view_angle[i]) == int, \ + 'the type of view_angle[0] and view_angle[1] should be "int"' + if view_dist is not None: + assert type(view_dist) == int, \ + 'the type of view_dist should be "int"' + + +def __density_matrix_convert_to_bloch_vector(density_matrix): + r"""该函数将密度矩阵转化为bloch球面上的坐标 + + Args: + density_matrix (numpy.ndarray): 输入的密度矩阵 + Returns: + bloch_vector (numpy.ndarray): 存储bloch向量的x,y,z坐标，向量的模长，向量的颜色 + """ + + # Pauli Matrix + pauli_x = np.array([[0, 1], [1, 0]]) + pauli_y = np.array([[0, -1j], [1j, 0]]) + pauli_z = np.array([[1, 0], [0, -1]]) + + # Convert a density matrix to a Bloch vector. + ax = np.trace(np.dot(density_matrix, pauli_x)).real + ay = np.trace(np.dot(density_matrix, pauli_y)).real + az = np.trace(np.dot(density_matrix, pauli_z)).real + + # Calc the length of bloch vector + length = ax ** 2 + ay ** 2 + az ** 2 + length = sqrt(length) + if length > 1.0: + length = 1.0 + + # Calc the color of bloch vector, the value of the color is proportional to the length + color = length + + bloch_vector = [ax, ay, az, length, color] + + # You must use an array, which is followed by slicing and taking a column + bloch_vector = np.array(bloch_vector) + + return bloch_vector + + +def __plot_bloch_sphere( + ax, + bloch_vectors=None, + show_arrow=False, + clear_plt=True, + rotating_angle_list=None, + view_angle=None, + view_dist=None +): + r"""将 Bloch 向量展示在 Bloch 球面上 + + Args: + ax (Axes3D(fig)): 画布的句柄 + bloch_vectors (numpy.ndarray): 存储bloch向量的x,y,z坐标，向量的模长，向量的颜色 + show_arrow (bool): 是否展示向量的箭头，默认为False + clear_plt (bool): 是否要清空画布，默认为True，每次画图的时候清空画布再画图 + rotating_angle_list (list): 旋转角度的列表，用于展示旋转轨迹 + view_angle (list): 视图的角度，list内第一个元素为关于xy平面的夹角[0-360],第二个元素为关于xz平面的夹角[0-360] + view_dist (int): 视图的距离，默认为7 + """ + # Assign a value to an empty variable + if view_angle is None: + view_angle = [30, 45] + if view_dist is None: + view_dist = 7 + + # Define my_color + color = 'rainbow' + black_code = '#000000' + red_code = '#F24A29' + if bloch_vectors is not None: + black_to_red = mplcolors.LinearSegmentedColormap.from_list( + 'my_color', + [(0, black_code), (1, red_code)], + N=len(bloch_vectors[:, 4]) + ) + map_vir = plt.get_cmap(black_to_red) + color = map_vir(bloch_vectors[:, 4]) + + # Set the view angle and view distance + ax.view_init(view_angle[0], view_angle[1]) + ax.dist = view_dist + + # Draw the general frame + def draw_general_frame(): + + # Do not show the grid and original axes + ax.grid(False) + ax.set_axis_off() + ax.view_init(view_angle[0], view_angle[1]) + ax.dist = view_dist + + # Set the lower limit and upper limit of each axis + # To make the bloch_ball look less flat, the default is relatively flat + ax.set_xlim3d(xmin=-1.5, xmax=1.5) + ax.set_ylim3d(ymin=-1.5, ymax=1.5) + ax.set_zlim3d(zmin=-1, zmax=1.3) + + # Draw a new axes + coordinate_start_x, coordinate_start_y, coordinate_start_z = \ + np.array([[-1.5, 0, 0], [0, -1.5, 0], [0, 0, -1.5]]) + coordinate_end_x, coordinate_end_y, coordinate_end_z = \ + np.array([[3, 0, 0], [0, 3, 0], [0, 0, 3]]) + ax.quiver( + coordinate_start_x, coordinate_start_y, coordinate_start_z, + coordinate_end_x, coordinate_end_y, coordinate_end_z, + arrow_length_ratio=0.03, color="black", linewidth=0.5 + ) + ax.text(0, 0, 1.7, r"|0⟩", color="black", fontsize=16) + ax.text(0, 0, -1.9, r"|1⟩", color="black", fontsize=16) + ax.text(1.9, 0, 0, r"|+⟩", color="black", fontsize=16) + ax.text(-1.7, 0, 0, r"|–⟩", color="black", fontsize=16) + ax.text(0, 1.7, 0, r"|i+⟩", color="black", fontsize=16) + ax.text(0, -1.9, 0, r"|i–⟩", color="black", fontsize=16) + + # Draw a surface + horizontal_angle = np.linspace(0, 2 * np.pi, 80) + vertical_angle = np.linspace(0, np.pi, 80) + surface_point_x = np.outer(np.cos(horizontal_angle), np.sin(vertical_angle)) + surface_point_y = np.outer(np.sin(horizontal_angle), np.sin(vertical_angle)) + surface_point_z = np.outer(np.ones(np.size(horizontal_angle)), np.cos(vertical_angle)) + ax.plot_surface( + surface_point_x, surface_point_y, surface_point_z, rstride=1, cstride=1, + color="black", linewidth=0.05, alpha=0.03 + ) + + # Draw circle + def draw_circle(circle_horizon_angle, circle_vertical_angle, linewidth=0.5, alpha=0.2): + r = 1 + circle_point_x = r * np.cos(circle_vertical_angle) * np.cos(circle_horizon_angle) + circle_point_y = r * np.cos(circle_vertical_angle) * np.sin(circle_horizon_angle) + circle_point_z = r * np.sin(circle_vertical_angle) + ax.plot( + circle_point_x, circle_point_y, circle_point_z, + color="black", linewidth=linewidth, alpha=alpha + ) + + # draw longitude and latitude + def draw_longitude_and_latitude(): + # Draw longitude + num = 3 + theta = np.linspace(0, 0, 100) + psi = np.linspace(0, 2 * np.pi, 100) + for i in range(num): + theta = theta + np.pi / num + draw_circle(theta, psi) + + # Draw latitude + num = 6 + theta = np.linspace(0, 2 * np.pi, 100) + psi = np.linspace(-np.pi / 2, -np.pi / 2, 100) + for i in range(num): + psi = psi + np.pi / num + draw_circle(theta, psi) + + # Draw equator + theta = np.linspace(0, 2 * np.pi, 100) + psi = np.linspace(0, 0, 100) + draw_circle(theta, psi, linewidth=0.5, alpha=0.2) + + # Draw prime meridian + theta = np.linspace(0, 0, 100) + psi = np.linspace(0, 2 * np.pi, 100) + draw_circle(theta, psi, linewidth=0.5, alpha=0.2) + + # If the number of data points exceeds 20, no longitude and latitude lines will be drawn. + if bloch_vectors is not None and len(bloch_vectors) < 52: + draw_longitude_and_latitude() + elif bloch_vectors is None: + draw_longitude_and_latitude() + + # Draw three invisible points + invisible_points = np.array([[0.03440399, 0.30279721, 0.95243384], + [0.70776026, 0.57712403, 0.40743499], + [0.46991358, -0.63717908, 0.61088792]]) + ax.scatter( + invisible_points[:, 0], invisible_points[:, 1], invisible_points[:, 2], + c='w', alpha=0.01 + ) + + # clean plt + if clear_plt: + ax.cla() + draw_general_frame() + + # Draw the data points + if bloch_vectors is not None: + ax.scatter( + bloch_vectors[:, 0], bloch_vectors[:, 1], bloch_vectors[:, 2], c=color, alpha=1 + ) + + # if show the rotating angle + if rotating_angle_list is not None: + bloch_num = len(bloch_vectors) + rotating_angle_theta, rotating_angle_phi, rotating_angle_lam = rotating_angle_list[bloch_num - 1] + rotating_angle_theta = round(rotating_angle_theta, 6) + rotating_angle_phi = round(rotating_angle_phi, 6) + rotating_angle_lam = round(rotating_angle_lam, 6) + + # Shown at the top right of the perspective + display_text_angle = [-(view_angle[0] - 10), (view_angle[1] + 10)] + text_point_x = 2 * np.cos(display_text_angle[0]) * np.cos(display_text_angle[1]) + text_point_y = 2 * np.cos(display_text_angle[0]) * np.sin(-display_text_angle[1]) + text_point_z = 2 * np.sin(-display_text_angle[0]) + ax.text(text_point_x, text_point_y, text_point_z, r'$\theta=' + str(rotating_angle_theta) + r'$', + color="black", fontsize=14) + ax.text(text_point_x, text_point_y, text_point_z - 0.1, r'$\phi=' + str(rotating_angle_phi) + r'$', + color="black", fontsize=14) + ax.text(text_point_x, text_point_y, text_point_z - 0.2, r'$\lambda=' + str(rotating_angle_lam) + r'$', + color="black", fontsize=14) + + # If show the bloch_vector + if show_arrow: + ax.quiver( + 0, 0, 0, bloch_vectors[:, 0], bloch_vectors[:, 1], bloch_vectors[:, 2], + arrow_length_ratio=0.05, color=color, alpha=1, + ) + + +def plot_state_in_bloch_sphere( + state, + show_arrow=False, + save_gif=False, + filename=None, + view_angle=None, + view_dist=None +): + r"""将输入的量子态展示在 Bloch 球面上 + + Args: + state (list(numpy.ndarray or paddle.Tensor)): 输入的量子态列表，可以支持态矢量和密度矩阵 + show_arrow (bool): 是否展示向量的箭头，默认为 ``False`` + save_gif (bool): 是否存储 gif 动图，默认为 ``False`` + filename (str): 存储的 gif 动图的名字 + view_angle (list or tuple): 视图的角度，list 内第一个元素为关于 xy 平面的夹角 [0-360]，第二个元素为关于 xz 平面的夹角 [0-360] + view_dist (int): 视图的距离，默认为 7 + """ + # Check input data + __input_args_dtype_check(show_arrow, save_gif, filename, view_angle, view_dist) + + assert type(state) == list or type(state) == paddle.Tensor or type(state) == np.ndarray, \ + 'the type of input data must be "list" or "paddle.Tensor" or "np.ndarray"' + if type(state) == paddle.Tensor or type(state) == np.ndarray: + state = [state] + state_len = len(state) + assert state_len >= 1, 'input data is NULL.' + for i in range(state_len): + assert type(state[i]) == paddle.Tensor or type(state[i]) == np.ndarray, \ + 'the type of input data should be "paddle.Tensor" or "numpy.ndarray".' + + # Assign a value to an empty variable + if filename is None: + filename = 'state_in_bloch_sphere.gif' + if view_angle is None: + view_angle = [30, 45] + if view_dist is None: + view_dist = 7 + + # Convert Tensor to numpy + for i in range(state_len): + if type(state[i]) == paddle.Tensor: + state[i] = state[i].numpy() + + # Convert state_vector to density_matrix + for i in range(state_len): + if state[i].size == 2: + state_vector = state[i] + state[i] = np.outer(state_vector, np.conj(state_vector)) + + # Calc the bloch_vectors + bloch_vector_list = [] + for i in range(state_len): + bloch_vector_tmp = __density_matrix_convert_to_bloch_vector(state[i]) + bloch_vector_list.append(bloch_vector_tmp) + + # List must be converted to array for slicing. + bloch_vectors = np.array(bloch_vector_list) + + # Helper function to plot vectors on a sphere. + fig = plt.figure(figsize=(8, 8), dpi=100) + fig.subplots_adjust(left=0, right=1, bottom=0, top=1) + ax = fig.add_subplot(111, projection='3d') + + # A update function for animation class + def update(frame): + stretch = 3 + view_rotating_angle = 5 + if frame <= stretch: + new_bloch_vectors = np.zeros(shape=(len(bloch_vectors), 0)) + for j in range(3): + bloch_column_tmp = bloch_vectors[:, j] / stretch * frame + new_bloch_vectors = np.insert(new_bloch_vectors, j, values=bloch_column_tmp, axis=1) + for j in range(2): + new_bloch_vectors = np.insert(new_bloch_vectors, 3 + j, values=bloch_vectors[:, 3 + j], axis=1) + + __plot_bloch_sphere( + ax, new_bloch_vectors, show_arrow, clear_plt=True, view_angle=view_angle, view_dist=view_dist + ) + + else: + new_view_angle = [view_angle[0], view_angle[1] + view_rotating_angle * (frame - stretch)] + __plot_bloch_sphere( + ax, bloch_vectors, show_arrow, clear_plt=True, view_angle=new_view_angle, view_dist=view_dist + ) + + # Dynamic update and save + if save_gif: + frames_num = 10 + anim = animation.FuncAnimation(fig, update, frames=frames_num, interval=600, repeat=False) + anim.save(filename, dpi=100, writer='Pillow') + else: + __plot_bloch_sphere( + ax, bloch_vectors, show_arrow, clear_plt=True, view_angle=view_angle, view_dist=view_dist + ) + + plt.show() + + +def plot_rotation_in_bloch_sphere( + init_state, + rotating_angle, + show_arrow=False, + save_gif=False, + filename=None, + view_angle=None, + view_dist=None +): + r"""在 Bloch 球面上刻画从初始量子态开始的旋转轨迹 + + Args: + init_state (numpy.ndarray or paddle.Tensor): 输入的初始量子态，可以支持态矢量和密度矩阵 + rotating_angle (list(float)): 旋转角度 ``[theta, phi, lam]`` + show_arrow (bool): 是否展示向量的箭头，默认为 ``False`` + save_gif (bool): 是否存储 gif 动图，默认为 ``False`` + filename (str): 存储的 gif 动图的名字 + view_angle (list or tuple): 视图的角度，list 内第一个元素为关于 xy 平面的夹角 [0-360]，第二个元素为关于 xz 平面的夹角 [0-360] + view_dist (int): 视图的距离，默认为 7 + """ + # Check input data + __input_args_dtype_check(show_arrow, save_gif, filename, view_angle, view_dist) + + assert type(init_state) == paddle.Tensor or type(init_state) == np.ndarray, \ + 'the type of input data should be "paddle.Tensor" or "numpy.ndarray".' + assert type(rotating_angle) == tuple or type(rotating_angle) == list, \ + 'the type of rotating_angle should be "tuple" or "list"' + assert len(rotating_angle) == 3, \ + 'the rotating_angle must include [theta=paddle.Tensor, phi=paddle.Tensor, lam=paddle.Tensor].' + for i in range(3): + assert type(rotating_angle[i]) == paddle.Tensor or type(rotating_angle[i]) == float, \ + 'the rotating_angle must include [theta=paddle.Tensor, phi=paddle.Tensor, lam=paddle.Tensor].' + + # Assign a value to an empty variable + if filename is None: + filename = 'rotation_in_bloch_sphere.gif' + if view_angle is None: + view_angle = [30, 45] + if view_dist is None: + view_dist = 7 + + theta, phi, lam = rotating_angle + + # Convert Tensor to numpy + if type(init_state) == paddle.Tensor: + init_state = init_state.numpy() + + # Convert state_vector to density_matrix + if init_state.size == 2: + state_vector = init_state + init_state = np.outer(state_vector, np.conj(state_vector)) + + # Rotating angle + def rotating_operation(rotating_angle_each): + gate_matrix = simulator.u_gate_matrix(rotating_angle_each) + return np.matmul(np.matmul(gate_matrix, init_state), gate_matrix.conj().T) + + # Rotating angle division + rotating_frame = 50 + rotating_angle_list = [] + state = [] + for i in range(rotating_frame + 1): + angle_each = [theta / rotating_frame * i, phi / rotating_frame * i, lam / rotating_frame * i] + rotating_angle_list.append(angle_each) + state.append(rotating_operation(angle_each)) + + state_len = len(state) + # Calc the bloch_vectors + bloch_vector_list = [] + for i in range(state_len): + bloch_vector_tmp = __density_matrix_convert_to_bloch_vector(state[i]) + bloch_vector_list.append(bloch_vector_tmp) + + # List must be converted to array for slicing. + bloch_vectors = np.array(bloch_vector_list) + + # Helper function to plot vectors on a sphere. + fig = plt.figure(figsize=(8, 8), dpi=100) + fig.subplots_adjust(left=0, right=1, bottom=0, top=1) + ax = fig.add_subplot(111, projection='3d') + + # A update function for animation class + def update(frame): + frame = frame + 1 + if frame <= len(bloch_vectors): + __plot_bloch_sphere( + ax, bloch_vectors[:frame], show_arrow=show_arrow, clear_plt=True, + rotating_angle_list=rotating_angle_list, + view_angle=view_angle, view_dist=view_dist + ) + + # The starting and ending bloch vector has to be shown + # show starting vector + __plot_bloch_sphere( + ax, bloch_vectors[:1], show_arrow=True, clear_plt=False, view_angle=view_angle, view_dist=view_dist, + ) + # Show ending vector + if frame == len(bloch_vectors): + __plot_bloch_sphere( + ax, bloch_vectors[frame - 1:frame], show_arrow=True, clear_plt=False, + view_angle=view_angle, view_dist=view_dist + ) + + # Dynamic update and save + stop_frames = 10 + frames_num = len(bloch_vectors) + stop_frames + anim = animation.FuncAnimation(fig, update, frames=frames_num, interval=100, repeat=False) + if save_gif: + anim.save(filename, dpi=100, writer='Pillow') + + plt.show() diff --git a/requirements.txt b/requirements.txt index d6c0a97..d11f537 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,6 +1,7 @@ -paddlepaddle>=2.0.1 +paddlepaddle>=2.1.1 scipy networkx>=2.5 matplotlib interval -tqdm \ No newline at end of file +tqdm +fastdtw \ No newline at end of file diff --git a/setup.py b/setup.py index 57e15f0..3275f99 100644 --- a/setup.py +++ b/setup.py @@ -23,7 +23,7 @@ with open("README.md", "r", encoding="utf-8") as fh: setuptools.setup( name='paddle-quantum', - version='2.1.0', + version='2.1.1', author='Institute for Quantum Computing, Baidu INC.', author_email='quantum@baidu.com', description='Paddle Quantum is a quantum machine learning (QML) toolkit developed based on Baidu PaddlePaddle.', @@ -34,7 +34,7 @@ setuptools.setup( 'paddle_quantum.VQE', 'paddle_quantum.VQSD', 'paddle_quantum.GIBBS.example', 'paddle_quantum.QAOA.example', 'paddle_quantum.SSVQE.example', 'paddle_quantum.VQE.example', 'paddle_quantum.VQSD.example'], - install_requires=['paddlepaddle>=2.0.1', 'scipy', 'networkx>=2.5', 'matplotlib', 'interval', 'tqdm'], + install_requires=['paddlepaddle>=2.1.1', 'scipy', 'networkx>=2.5', 'matplotlib', 'interval', 'tqdm', 'fastdtw'], python_requires='>=3.6, <4', classifiers=[ 'Programming Language :: Python :: 3', diff --git a/tutorial/combinatorial_optimization/ArbitrageOpportunityOptimation_CN.ipynb b/tutorial/combinatorial_optimization/ArbitrageOpportunityOptimation_CN.ipynb new file mode 100644 index 0000000..a1b3dc6 --- /dev/null +++ b/tutorial/combinatorial_optimization/ArbitrageOpportunityOptimation_CN.ipynb @@ -0,0 +1,531 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "source": [ + "# 量子金融应用：最佳套利机会\n", + "\n", + " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "## 概览\n", + "\n", + "当前量子计算应用到金融问题上的解决方案通常可分为三类量子算法，即量子模拟，量子优化以及量子机器学习 [1,2]。许多的金融问题本质上是一个组合优化问题，解决这些问题的算法通常具有较高的时间复杂度，实现难度较大。得益于量子计算强大的计算性能，未来有望通过量子算法解决这些复杂问题。\n", + "\n", + "量桨的 Quantum Finance 模块主要讨论的是量子优化部分的内容，即如何通过一些量子算法解决实际金融应用中的优化问题。本文主要介绍如何使用量子算法求解最佳套利机会问题 [3]。" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "## 最佳套利机会问题\n", + "\n", + "套利（Arbitrage）一般指相同的资产在不同的市场中有不同价格，可以通过在多个市场间的转换，获得正向收益。也就是说，如果给定一组资产和交易成本，那么就可能在不同市场间存在一个交易循环产生正向收益。\n", + "\n", + "这个问题可以用图论的语言来描述：给定一个带权重的有向图 $G$ ，顶点 $i$ 表示一种市场货币，从顶点 $i$ 到顶点 $j$ 的边的权重表示将货币 $i$ 转换为货币 $j$的转换率 $c_{ij} $。也就是说如果拥有数量为 $x_i$ 的货币 $i$，那么通过交易转换我们将得到 $c_{ij}x_i$ 的货币 $j$。通常来讲转换率不是对称的，即 $c_{ij} \\neq c_{ji}$，并且我们假设交易成本（服务供应商收取的服务费，买入和卖出时的手续费等）是已经包含在该转换率中的。\n", + "\n", + "我们固定可交易的货币种类数量为 $n$，则该优化问题就是在给定的加权有向图上寻找一个获利最大回路，该回路中包含的顶点数量为 $K (K \\leq n)$。找到的最佳套利回路就是从某一市场出发，使得资产转换一圈后收益最大的交易路径。在该问题中，用户可以自行定义套利回路中包含的顶点数 $K$。" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "## 编码最佳套利机会问题\n", + "\n", + "为了将最佳套利机会问题转化成一个参数化量子电路（parameterized quantum circuits, PQC）可解的问题，我们首先需要编码该问题的哈密顿量。第一步是将该问题转化为一个整数规划问题：给定一个整数 $n$, 即最佳套利机会问题涉及的货币种类数量, 也就是图形 $G$ 的顶点数量为 $|V| = n$ 个，那么对于每个顶点 $i \\in V$，我们定义 $n$ 个二进制变量 $x_{i,k}$，$k \\in [0,K-1]$：\n", + "\n", + "$$\n", + "x_{i, k}=\\begin{cases}\n", + "1, & \\text{资产转换到市场 $i$ 的次序为 $k$}\\\\\n", + "0, & \\text{其他情况}\n", + "\\end{cases}.\n", + "\\tag{1}\n", + "$$\n", + "\n", + "参考旅行商问题（[TSP 教程](./TSP_CN.ipynb)），因为 $G$ 有 $n$ 个顶点，所以我们共有 $n^2$ 个变量 $x_{i,k}$，所有这些变量的取值我们用 $x = x_{0,0} x_{0,1}\\dots x_{n-1,K-1}$ 来表示。在这里我们假设 $x$ 对应一个套利回路，那么对于图中的每一条边 $(i,j,w_{i,j})\\in E$，条件 $x_{i,k}·x_{j,k+1} = 1$ 成立当且仅当套利回路中第 $k$ 个顶点为顶点 $i$ 且 第 $k+1$ 个顶点是顶点 $j$。可以通过下面的式子计算资产在套利回路转换一圈后所获利的对数：\n", + "\n", + "$$\n", + "P(x) = - \\sum_{i,j\\in V} \\log(c_{ij}) \\sum_{k=0}^{K-1} x_{i,k}x_{j,k+1}, \\tag{2}\n", + "$$\n", + "\n", + "根据套利回路的定义，$x$ 如果对应一条套利回路，那么就需要满足如下的限制：\n", + "\n", + "$$\n", + "\\sum_{i=0}^{n-1} x_{i,k} = 1 \\quad \\text{和} \\quad \\sum_{k=0}^{K-1}\\sum_{(i,j)\\notin E}x_{i,k}x_{j, k+1}, \\tag{3}\n", + "$$\n", + "\n", + "其中第一个式子用来保证找到的 $x$ 所代表的回路中同一时刻只可能出现一个顶点，第二个保证不存在的边不会出现在最后的套利回路中。这两个式子共同保证了参数化量子电路找到的 $x$ 是个简单回路。因为后续要用梯度下降方法对损失函数进行优化求最小值，对上述式子稍作调整给出损失函数：\n", + "\n", + "$$\n", + "C_x = - P(x) + A\\sum_{k=0}^{K-1} \\left(1 - \\sum_{i=0}^{n-1} x_{i,k}\\right)^2 + A\\sum_{k=0}^{K-1}\\sum_{(i,j)\\notin E}\n", + "x_{i,k}x_{j,k+1}.\n", + "\\tag{4}\n", + "$$\n", + "\n", + "在这个式子中 $V$ 是图中顶点个数，$E$ 表示图中边的集合，$K$ 是套利圈中顶点的个数，$A$ 是惩罚参数，它保证了上述的限制被遵守。因为我们想要在找套利回路 $P(x)$ 最大值的同时保证 $x$ 确实表示一个回路，所以我们需要设置一个大一点的 $A$，最起码大过图 $G$ 中边的最大的权重，从而保证不遵守限制的路线不会成为最终的路线。\n", + "\n", + "我们现在需要将损失函数 $C_x$ 转化为一个哈密顿量从而完成最佳套利问题的编码。每一个二进制变量可以取 $0$ 和 $1$ 两个值，分别对应量子态 $|0\\rangle$ 和 $|1\\rangle$。每个二进制变量都对应一个量子比特，所以我们需要 $n^2$ 个量子比特来解决最佳套利机会问题。因为我们的变量 $x_{i,k}$ 的值为 $0$ 和 $1$，所以我们要构造一个本征值和它对应的哈密顿量。泡利 $Z$ 的本征值为 $\\pm 1$，于是我们构造的哈密顿量为 $\\frac{I-Z}{2}$， 对应的本征值即为 $0$ 和 $1$。我们现在将二进制变量映射到这个哈密顿矩阵上，从而使 $C_x$ 转化成哈密顿矩阵：\n", + "\n", + "$$\n", + "x_{i,k} \\mapsto \\frac{I-Z_{i,k}}{2}, \\tag{5}\n", + "$$\n", + "\n", + "这里 $Z_{i,k} = I \\otimes I \\otimes \\ldots \\otimes Z \\otimes \\ldots \\otimes I$，也就是说 $Z$ 作用在位置为 $(i,k)$ 的量子比特上。通过这个映射，如果一个编号为 $(i,k)$ 的量子比特的量子态为 $|1\\rangle$，那么对应的二进制变量的取值为 $x_{i,k} |1\\rangle = \\frac{I-Z_{i,k}}{2} |1\\rangle = 1|1\\rangle $，也就是说顶点 $i$ 在最佳套利回路中的交易顺序是 $k$。同样地，对于量子态为 $|0\\rangle$的量子比特 $(i,k)$，它所对应的二进制变量的取值为 $x_{i,k}|0\\rangle = \\frac{I-Z_{i,k}}{2} |0\\rangle = 0 |0\\rangle $。\n", + "\n", + "我们用上述映射将 $C_x$ 转化成量子比特数为 $n^2$ 的系统的哈密顿矩阵 $H_C$，从而实现了最佳套利机会问题的量子化。这个哈密顿矩阵 $H_C$ 的基态即为最佳套利机会问题的最优解。在接下来的部分，我们将展示如何用参数化量子电路找到这个矩阵的基态，也就是对应最小本征值的本征态。" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "## Paddle Quantum 实现\n", + "\n", + "要在量桨上实现用参数化量子电路解决量子金融中的最佳套利机会问题，首先要做的便是加载需要用到的包。其中 `networkx` 包可以帮助我们方便地查看和处理图。" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 1, + "source": [ + "#加载需要的包\n", + "import numpy as np\n", + "import networkx as nx\n", + "import matplotlib.pyplot as plt\n", + "\n", + "#加载飞桨，量桨相关的模块\n", + "import paddle\n", + "from paddle_quantum.circuit import UAnsatz\n", + "from paddle_quantum.finance import arbitrage_opportunities_hamiltonian" + ], + "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:00:15.901429Z", + "start_time": "2021-05-17T08:00:12.708945Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "接下来，我们先生成用于最佳套利机会问题的图 $G$。为了运算方便，图中的顶点从0开始计数。\n", + "\n", + "同时，为了方便运算验证，这里构造的加权有向图中对权值做了特殊设定。在实际使用过程中用户可以自行构造需要计算的货币类型，设置真实的货币汇率。" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 4, + "source": [ + "# n 代表图形 G 的顶点数量————指不同国家的货币\n", + "n = 3\n", + "nodes = [ \"JPY\", \"CNY\", \"USD\"]\n", + "G = nx.DiGraph()\n", + "G.add_nodes_from(nodes)\n", + "edges = [(\"JPY\",\"CNY\", 0.5), (\"CNY\",\"JPY\",2), (\"CNY\",\"USD\", 0.33), (\"USD\",\"CNY\",3),(\"JPY\",\"USD\", 0.25), (\"USD\",\"JPY\",4)]\n", + "G.add_weighted_edges_from(edges)\n", + "\n", + "# 两幅图分别表示不同方向的转换率\n", + "G1 = nx.DiGraph()\n", + "G1.add_nodes_from(nodes)\n", + "edges1 = [(\"JPY\",\"CNY\", 0.5), (\"CNY\",\"USD\", 0.33), (\"USD\",\"JPY\",4)]\n", + "G1.add_weighted_edges_from(edges1)\n", + "\n", + "G2 = nx.DiGraph()\n", + "G2.add_nodes_from(nodes)\n", + "edges2 = [(\"CNY\",\"JPY\",2), (\"USD\",\"CNY\",3),(\"JPY\",\"USD\", 0.25)]\n", + "G2.add_weighted_edges_from(edges2)\n", + "\n", + "options = {\n", + " \"with_labels\": True,\n", + " \"font_weight\": \"bold\",\n", + " \"font_color\": \"white\",\n", + " \"node_size\": 2000,\n", + " \"width\": 2\n", + "}\n", + "fig, ax = plt.subplots(1, 2, figsize=(15, 4))\n", + "for i, a in enumerate(ax):\n", + " a.axis('off')\n", + " a.margins(0.20)\n", + "nx.draw(G1, pos=nx.circular_layout(G1), ax=ax[0], **options)\n", + "nx.drawing.nx_pylab.draw_networkx_edge_labels(G1, pos=nx.circular_layout(G1), ax=ax[0], edge_labels=nx.get_edge_attributes(G1, 'weight'))\n", + "nx.draw(G2, pos=nx.circular_layout(G2), ax=ax[1], **options)\n", + "nx.drawing.nx_pylab.draw_networkx_edge_labels(G2, pos=nx.circular_layout(G2), ax=ax[1], edge_labels=nx.get_edge_attributes(G2, 'weight'))\n", + "plt.axis(\"off\")\n", + "plt.show()" + ], + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {} + } + ], + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:00:16.212260Z", + "start_time": "2021-05-17T08:00:15.918792Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "### 编码哈密顿量\n", + "\n", + "这里我们将式（4）中的二进制变量用式（5）替换，从而构建哈密顿量 $H_C$。" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 4, + "source": [ + "# 惩罚参数 等于构造的有向图中权值最大的边\n", + "penalty = 4 \n", + "# 在本样例中，设定交易回路内货币数量为全部的货币种类\n", + "K = n \n", + "# 构建最佳套利问题的哈密顿量\n", + "hamiltonian = arbitrage_opportunities_hamiltonian(G, penalty, n, K)" + ], + "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:00:16.237497Z", + "start_time": "2021-05-17T08:00:16.219567Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "### 计算损失函数\n", + "\n", + "我们使用 $U_3(\\vec{\\theta})$ 和 $\\text{CNOT}$ 门构造的参数化量子电路，通过调用量桨内部的 [`complex entangled layer`](https://qml.baidu.com/api/paddle_quantum.circuit.uansatz.html) 来实现。\n", + "\n", + "上述电路会给出一个输出态 $|\\vec{\\theta}\\rangle$，由此输出态，我们可以定义最佳套利机会问题在经典-量子混合模型下的损失函数：\n", + "\n", + "$$\n", + "L(\\vec{\\theta}) = \\langle\\vec{\\theta}|H_C|\\vec{\\theta}\\rangle.\n", + "\\tag{6}\n", + "$$\n", + "\n", + "之后我们利用经典的优化算法寻找最优参数 $\\vec{\\theta}^*$。下面的代码给出了通过量桨和飞桨搭建的完整网络：" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 5, + "source": [ + "class AONet(paddle.nn.Layer):\n", + "\n", + " def __init__(self, n, p, K, dtype=\"float64\"):\n", + " super(AONet, self).__init__()\n", + "\n", + " self.p = p\n", + " self.num_qubits = n * K\n", + " self.theta = self.create_parameter(shape=[self.p, self.num_qubits, 3],\n", + " default_initializer=paddle.nn.initializer.Uniform(low=0, high=2 * np.pi),\n", + " dtype=dtype, is_bias=False)\n", + "\n", + " def forward(self, hamiltonian):\n", + " \"\"\"\n", + " 前向传播\n", + " \"\"\"\n", + " cir = UAnsatz(self.num_qubits)\n", + " cir.complex_entangled_layer(self.theta, self.p)\n", + " cir.run_state_vector()\n", + " loss = cir.expecval(hamiltonian)\n", + "\n", + " return loss, cir\n" + ], + "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:00:16.258893Z", + "start_time": "2021-05-17T08:00:16.241066Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "### 训练量子神经网络\n", + "\n", + "定义好了量子神经网络后，我们使用梯度下降的方法来优化其中的参数，使得式（6）的期望值最小。" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 6, + "source": [ + "SEED = 100 # 随机数种子\n", + "p = 1 # 量子电路的层数\n", + "ITR = 120 # 迭代次数\n", + "LR = 0.4 # 梯度下降优化速率 " + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "使用飞桨，优化上面定义的网络。" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 7, + "source": [ + "# 固定 paddle 随机种子\n", + "paddle.seed(SEED)\n", + "\n", + "# 定义量子神经网络\n", + "net = AONet(n, p, K)\n", + "\n", + "# 使用 Adam 优化器\n", + "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters())\n", + "# 梯度下降优化循环\n", + "for itr in range(1, ITR + 1):\n", + " # 运行上面定义的网络\n", + " loss, cir = net(hamiltonian)\n", + " #计算梯度并优化\n", + " loss.backward()\n", + " opt.minimize(loss)\n", + " opt.clear_grad()\n", + " if itr % 10 == 0:\n", + " print(\"循环数：\", itr, \" 损失:\", \"%.4f\"% loss.numpy())" + ], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "循环数： 10 损失: 0.4704\n", + "循环数： 20 损失: 0.1302\n", + "循环数： 30 损失: -0.2744\n", + "循环数： 40 损失: -0.4700\n", + "循环数： 50 损失: -0.5512\n", + "循环数： 60 损失: -0.5684\n", + "循环数： 70 损失: -0.5821\n", + "循环数： 80 损失: -0.5833\n", + "循环数： 90 损失: -0.5843\n", + "循环数： 100 损失: -0.5847\n", + "循环数： 110 损失: -0.5849\n", + "循环数： 120 损失: -0.5849\n" + ] + } + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### 解码量子答案\n", + "\n", + "当求得损失函数的最小值以及对应的一组参数 $\\vec{\\mathbf{\\theta}}^*$后，我们的任务还没有完成。为了进一步求得最佳套利机会问题的近似解，需要从电路输出的量子态 $|\\vec{\\mathbf{\\theta}}^*\\rangle$ 中解码出最佳套利问题的答案。物理上，解码量子态需要对量子态进行测量，然后统计测量结果的概率分布（我们的测量结果是表示最佳套利机会问题答案的比特串）：\n", + "\n", + "$$\n", + "p(z) = |\\langle z|\\vec{\\mathbf{\\theta}}^*\\rangle|^2.\n", + "\\tag{6}\n", + "$$\n", + "\n", + "在量子参数化电路表达能力足够的情况下，某个比特串出现的概率越大，意味着其是最佳套利机会问题最优解的可能性越大。\n", + "\n", + "量桨提供了查看参数化量子电路输出状态的测量结果概率分布的函数：" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 8, + "source": [ + "# 模拟重复测量电路输出态 1024 次\n", + "prob_measure = cir.measure(shots=1024)\n", + "arbitrage_opportunity_route = max(prob_measure, key=prob_measure.get)\n", + "print(\"利用哈密顿量找到的解的比特串形式：\", arbitrage_opportunity_route)" + ], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "利用哈密顿量找到的解的比特串形式： 100001010\n" + ] + } + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "概率最大的测量结果是表示最佳套利机会问题答案的比特串。返回的二进制字符串每 $n$ 位一组，每组中的第 $k$ 位为 $1$ 表示该笔资产交易到该市场时的顺序为 $k$ 。如果最后的结果不是类似的有效解，读者可以通过调整参数化量子电路的参数值，即随机种子 `SEED`、层数 `p`、迭代次数 `ITR` 和梯度下降优化速率 `LR`，来获得更好的训练效果。\n", + "\n", + "我们将找到的比特串映射回经典解，即转化成了 ``dictionary`` 的形式。其中 ``key`` 代表货币名称，``value`` 代表顶点在套利回路中的顺序，即一笔资产交易到该市场的顺序。在下面的代码中，我们还计算了该笔资产经找到套利回路交易一圈后的正向回报率。" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 9, + "source": [ + "solution = {nodes[i]:t for i in range(n) for t in range(n) if arbitrage_opportunity_route[i * n + t] == '1'}\n", + "print(solution)\n", + "rate = sum([np.log2(G[u][v][\"weight\"]) if solution[v] == (solution[u] + 1) % n else 0 for (u, v) in G.edges])\n", + "print(\"正向回报率: \", 2**rate)" + ], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "{'JPY': 0, 'CNY': 2, 'USD': 1}\n", + "正向回报率: 1.5\n" + ] + } + ], + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:02:14.554317Z", + "start_time": "2021-05-17T08:02:14.500593Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "为了清晰地表达资产的交易路径，依然选择以图的形式呈现：\n", + "* 顶点中的数字代表交易到该货币市场的顺序，字母代表不同的货币类型\n", + "* 红色的有向边表示找到的最佳路线" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 10, + "source": [ + "label_dict = {i: str(i) + \", \" + str(t) for i, t in solution.items()}\n", + "edge_color1 = [\"red\" if solution[v] == (solution[u] + 1) % n else \"black\"\n", + " for (u, v) in G1.edges]\n", + "edge_color2 = [\"red\" if solution[v] == (solution[u] + 1) % n else \"black\"\n", + " for (u, v) in G2.edges]\n", + "\n", + "# 在图上画出找到的最优路线\n", + "fig, ax = plt.subplots(1, 2, figsize=(15, 4))\n", + "for i, a in enumerate(ax):\n", + " a.axis('off')\n", + " a.margins(0.20)\n", + "nx.draw(G1, pos=nx.circular_layout(G1), labels=label_dict, edge_color=edge_color1, ax=ax[0], **options)\n", + "nx.drawing.nx_pylab.draw_networkx_edge_labels(G1, pos=nx.circular_layout(G1), ax=ax[0], edge_labels=nx.get_edge_attributes(G1, 'weight'))\n", + "nx.draw(G2, pos=nx.circular_layout(G2), labels=label_dict, edge_color=edge_color2, ax=ax[1], **options)\n", + "nx.drawing.nx_pylab.draw_networkx_edge_labels(G2, pos=nx.circular_layout(G2), ax=ax[1], edge_labels=nx.get_edge_attributes(G2, 'weight'))\n", + "plt.axis(\"off\")\n", + "plt.show()" + ], + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {} + } + ], + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:02:14.571954Z", + "start_time": "2021-05-17T08:02:14.559634Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "上面给出的左图展示了未被选中的交易路线，右图展示了该算法找到的最优套利回路。" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### 结语\n", + "\n", + "在本教程中，针对套利问题，给出了一种寻找最优套利回路的经典量子混合算法。对于 $n$ 个货币市场，在该解决方案中，我们需要 $n^2$ 个量子比特。在样例中，我们设定的不同市场间的汇率比较特殊且把交易成本包含在内，所以会产生高达 $150\\%$ 的正向收益率。用户在使用时可以根据需求，自行设定真实的货币汇率。\n", + "\n", + "在实际的金融市场中，一般不会有如此高的投资回报率，而且考虑的货币市场数量比较大，需要考虑的因素也更多。因此，随着货币数量的增加，所需的量子比特数也急速增加，实现难度也就越大。" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "_______\n", + "\n", + "## 参考文献\n", + "\n", + "[1] Orus, Roman, Samuel Mugel, and Enrique Lizaso. \"Quantum computing for finance: Overview and prospects.\" [Reviews in Physics 4 (2019): 100028.](https://arxiv.org/abs/1807.03890)\n", + "\n", + "[2] Egger, Daniel J., et al. \"Quantum computing for Finance: state of the art and future prospects.\" [IEEE Transactions on Quantum Engineering (2020).](https://arxiv.org/abs/2006.14510)\n", + "\n", + "[3] Rosenberg, G. \"Finding optimal arbitrage opportunities using a quantum annealer.\" [1QB Information Technologies Write Paper (2016): 1-7.](https://1qbit.com/whitepaper/arbitrage/)" + ], + "metadata": {} + } + ], + "metadata": { + "interpreter": { + "hash": "3b61f83e8397e1c9fcea57a3d9915794102e67724879b24295f8014f41a14d85" + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3.7.11 64-bit ('pq_env': conda)" + }, + "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.7.11" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} \ No newline at end of file diff --git a/tutorial/combinatorial_optimization/ArbitrageOpportunityOptimation_EN.ipynb b/tutorial/combinatorial_optimization/ArbitrageOpportunityOptimation_EN.ipynb new file mode 100644 index 0000000..aba02f2 --- /dev/null +++ b/tutorial/combinatorial_optimization/ArbitrageOpportunityOptimation_EN.ipynb @@ -0,0 +1,527 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "source": [ + "# Quantum Finance Application on Arbitrage Opportunity Optimization\n", + "\n", + " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "## Overview\n", + "\n", + "Current finance problems can be mainly tackled by three areas of quantum algorithms: quantum simulation, quantum optimization, and quantum machine learning [1,2]. Many financial problems are essentially combinatorial optimization problems, and corresponding algorithms usually have high time complexity and are difficult to implement. Due to the power of quantum computing, these complex problems are expected to be solved by quantum algorithms in the future.\n", + "\n", + "The Quantum Finance module of Paddle Quantum focuses on quantum optimization: how to apply quantum algorithms in real finance optimization problems. This tutorial focuses on how to use quantum algorithms to solve the arbitrage opportunity optimization problem [3].\n" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "## Arbitrage Opportunity Optimization \n", + "\n", + "Arbitrage describes the fact that the same asset has different prices in different markets and can be traded between multiple markets to generate a positive return. That is, given a set of assets and transaction costs, it is possible to have a cycle among different markets that can generate a positive return.\n", + "\n", + "This problem can be formulated in the language of graph theory: given a weighted directed graph $G$ with vertex $i$ denoting $i$ th market currency, the weight of the edge from vertex $i$ to vertex $j$ denoting the exchange rate $c_{ij} $ that converts currency $i$ to currency $j$. That is, if we have a currency $i$ of quantity $x_i$, then by the exchange rate we will get a currency $j$ of quantity $c_{ij}x_i$. In general, the exchange rate is not symmetric, i.e. $c_{ij} \\neq c_{ji}$. We also assume that transaction costs (service fees etc.) are already included in the exchange rate.\n", + "\n", + "Given the number of tradable currency types $n$, the optimization problem is to find a cycle of the maximal profit on the given directed graph with $K (K \\leq n)$ vertices. In this finance module, users can define the number of vertices contained in the arbitrage cycle $K$ according to their requirements.\n" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### Encoding Arbitrage Opportunity Optimization Problem\n", + "\n", + "To transform the arbitrage opportunity optimization problem into a problem applicable for parameterized quantum circuits, we need to encode the arbitrage opportunity optimization problem into a Hamiltonian. We realize the encoding by first constructing an integer programming problem. Suppose there are $|V|=n$ vertices in graph $G$. Then for each vertex $i \\in V$, we define $n$ binary variables $x_{i,k}$, where $k \\in [0,K-1]$, such that\n", + "\n", + "$$\n", + "x_{i, k}=\n", + "\\begin{cases}\n", + "1, & \\text{the order of traded to vertex } i \\text { in the arbitrage cycle is $k$}\\\\\n", + "0, & \\text{otherwise}\n", + "\\end{cases}.\n", + "\\tag{1}\n", + "$$\n", + "\n", + "Refering to the Travelling Salesman Problem ([TSP tutorial](./TSP_CN.ipynb)), since $G$ has $n$ vertices, we have $n^2$ variables in total, whose value we denote by a bit string $x=x_{0,0}x_{0,1}\\dots x_{n-1,K-1}$. Assume for now that the bit string $x$ represents a arbitrage cycle. Then for each edge $(i,j,w_{i,j}) \\in E$, we will have $x_{i,k} = x_{j,k+1}=1$, i.e., $x_{i,k}\\cdot x_{j,k+1}=1$, if and only if the arbitrage cycle visits vertex $i$ at time $k$ and vertex $j$ at time $k+1$. Otherwise, $x_{i,k}\\cdot x_{j,k+1}$ will be $0$. Therefore the logarithm of the profit of the cycle is:\n", + "\n", + "$$\n", + "P(x) = - \\sum_{i,j\\in V} \\log(c_{ij}) \\sum_{k=0}^{K-1} x_{i,k}x_{j,k+1}, \\tag{2}\n", + "$$\n", + "\n", + "For $x$ to represent a valid arbitrage cycle, the following constraint needs to be met:\n", + "\n", + "$$\n", + "\\sum_{i=0}^{n-1} x_{i,k} = 1 \\quad \\text{and} \\quad \\sum_{k=0}^{K-1}\\sum_{(i,j)\\notin E}x_{i,k}x_{j, k+1}, \\tag{3}\n", + "$$\n", + "\n", + "where the first equation guarantees that only one vertex is visited at each time $k$. The second term constrains that a nonexistent edge does not appear in the found arbitrage cycle. These two equations ensure that the parameterized quantum circuits find $𝑥$ as a simple loop. Then the cost function under the constraint can be formulated below:\n", + "$$\n", + "C_x = - P(x) + A\\sum_{k=0}^{K-1} \\left(1 - \\sum_{i=0}^{n-1} x_{i,k}\\right)^2 + A\\sum_{k=0}^{K-1}\\sum_{(i,j)\\notin E}\n", + "x_{i,k}x_{j,k+1}.\n", + "\\tag{4}\n", + "$$\n", + "In this equation, $V$ is the number of vertices of the graph, $E$ is the edge set of the graph and $K$ are the number of vertices of the most profitable cycle. Note that as we would like to maximize the $P(x)$ while ensuring $x$ represents a valid arbitrage cycle, we had better set $A$ large, at least larger than the largest weight of edges.\n", + "\n", + "We now need to transform the cost function $C_x$ into a Hamiltonian to realize the encoding of the arbitrage opportunity optimization problem. Each variable $x_{i,k}$ has two possible values, $0$ and $1$, corresponding to quantum states $|0\\rangle$ and $|1\\rangle$. Note that every variable corresponds to a qubit and so $n^2$ qubits are needed for solving the arbitrage opportunity optimization problem. The Pauli $Z$ operator has two eigenstates, $|0\\rangle$ and $|1\\rangle$ . Their corresponding eigenvalues are 1 and -1, respectively. So we consider encoding the cost function as a Hamiltonian using the pauli $Z$ matrix.\n", + "\n", + "Now we would like to consider the mapping\n", + "$$\n", + "x_{i,k} \\mapsto \\frac{I-Z_{i,k}}{2}, \\tag{3}\n", + "$$\n", + "\n", + "where $Z_{i,k} = I \\otimes I \\otimes \\ldots \\otimes Z \\otimes \\ldots \\otimes I$ with $Z$ operates on the qubit at position $(i,k)$. Under this mapping, the value of $x_{i,k}$ can be illustrated in a different way. If the qubit $(i,k)$ is in state $|1\\rangle$, then $x_{i,k} |1\\rangle = \\frac{I-Z_{i,k}}{2} |1\\rangle = 1|1\\rangle $, which means vertex $i$ is visited at time $k$. Also, for the qubit $(i,k)$ in state $|0\\rangle$, $x_{i,k}|0\\rangle = \\frac{I-Z_{i,k}}{2} |0\\rangle = 0 |0\\rangle $.\n", + "\n", + "Thus using the above mapping, we can transform the cost function $C_x$ into a Hamiltonian $H_C$ for the system of $n^2$ qubits and realize the quantumization of the arbitrage opportunity optimization problem. Then the ground state of $H_C$ is the optimal solution to the arbitrage opportunity optimization problem. In the following section, we will show how to use a parameterized quantum circuit to find the ground state, i.e., the eigenvector with the smallest eigenvalue." + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "## Paddle Quantum Implementation\n", + "\n", + "To investigate the arbitrage opportunity optimization problem using Paddle Quantum, there are some required packages to import, which are shown below. The ``networkx`` package is the tool to handle graphs." + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 1, + "source": [ + "# Import packages needed\n", + "import numpy as np\n", + "import networkx as nx\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Import related modules from Paddle Quantum and PaddlePaddle\n", + "import paddle\n", + "from paddle_quantum.circuit import UAnsatz\n", + "from paddle_quantum.finance import arbitrage_opportunities_hamiltonian" + ], + "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:00:15.901429Z", + "start_time": "2021-05-17T08:00:12.708945Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "Next, we generate a weighted directed graph $G$ with $3$ vertices. For the convenience of computation, the vertices here are labeled starting from $0$.\n", + "\n", + "At the same time, in order to verify the solution more easily, special values are assigned for the weights in the directed graph. In practice, users can construct their own desired graphs and set the real exchange rates." + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "# n is the number of vertices in the graph G\n", + "n = 3\n", + "nodes = [ \"JPY\", \"CNY\", \"USD\"]\n", + "G = nx.DiGraph()\n", + "G.add_nodes_from(nodes)\n", + "edges = [(\"JPY\",\"CNY\", 0.5), (\"CNY\",\"JPY\",2), (\"CNY\",\"USD\", 0.33), (\"USD\",\"CNY\",3),(\"JPY\",\"USD\", 0.25), (\"USD\",\"JPY\",4)]\n", + "G.add_weighted_edges_from(edges)\n", + "\n", + "# The two graphs represent the exchange rates in different directions\n", + "G1 = nx.DiGraph()\n", + "G1.add_nodes_from(nodes)\n", + "edges1 = [(\"JPY\",\"CNY\", 0.5), (\"CNY\",\"USD\", 0.33), (\"USD\",\"JPY\",4)]\n", + "G1.add_weighted_edges_from(edges1)\n", + "\n", + "G2 = nx.DiGraph()\n", + "G2.add_nodes_from(nodes)\n", + "edges2 = [(\"CNY\",\"JPY\",2), (\"USD\",\"CNY\",3),(\"JPY\",\"USD\", 0.25)]\n", + "G2.add_weighted_edges_from(edges2)\n", + "\n", + "\n", + "options = {\n", + " \"with_labels\": True,\n", + " \"font_weight\": \"bold\",\n", + " \"font_color\": \"white\",\n", + " \"node_size\": 2000,\n", + " \"width\": 2\n", + "}\n", + "fig, ax = plt.subplots(1, 2, figsize=(15, 4))\n", + "for i, a in enumerate(ax):\n", + " a.axis('off')\n", + " a.margins(0.20)\n", + "nx.draw(G1, pos=nx.circular_layout(G1), ax=ax[0], **options)\n", + "nx.drawing.nx_pylab.draw_networkx_edge_labels(G1, pos=nx.circular_layout(G1), ax=ax[0], edge_labels=nx.get_edge_attributes(G1, 'weight'))\n", + "nx.draw(G2, pos=nx.circular_layout(G2), ax=ax[1], **options)\n", + "nx.drawing.nx_pylab.draw_networkx_edge_labels(G2, pos=nx.circular_layout(G2), ax=ax[1], edge_labels=nx.get_edge_attributes(G2, 'weight'))\n", + "plt.axis(\"off\")\n", + "plt.show()" + ], + "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:00:16.212260Z", + "start_time": "2021-05-17T08:00:15.918792Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "### Encoding Hamiltonian\n", + "\n", + "Here we construct the Hamiltonian $H_C$ of Eq. (4) with the replacement in Eq. (5). \n" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 3, + "source": [ + "# Penalty parameter: in this case, it is equal to the maximum weight of the edges in the directed graph\n", + "penalty = 4 \n", + "# In this example, all currency types are selected within the transaction cycle\n", + "K = n\n", + "# Construct the Hamiltonian of arbitrage opportunity optimization\n", + "hamiltonian = arbitrage_opportunities_hamiltonian(G, penalty, n, K)" + ], + "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:00:16.237497Z", + "start_time": "2021-05-17T08:00:16.219567Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "### Calculating the loss function \n", + "\n", + "We adopt a parameterized quantum circuit consisting of $U_3(\\vec{\\theta})$ and $\\text{CNOT}$ gates, that can be done by calling the built-in function [`complex entangled layer`](https://qml.baidu.com/api/paddle_quantum.circuit.uansatz.html).\n", + "\n", + "After running the quantum circuit, we obtain the output circuit $|\\vec{\\theta\n", + "}\\rangle$. From the output state of the circuit, we can define the loss function of the arbitrage opportunity optimization under the classical-quantum hybrid model:\n", + "\n", + "$$\n", + "L(\\vec{\\theta}) = \\langle\\vec{\\theta}|H_C|\\vec{\\theta}\\rangle.\n", + "\\tag{6}\n", + "$$\n", + "\n", + "We then use a classical optimization algorithm to minimize this function and find the optimal parameters $\\vec{\\theta}^*$. The following code shows a complete network built with Paddle Quantum and PaddlePaddle." + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 4, + "source": [ + "class AONet(paddle.nn.Layer):\n", + " def __init__(self, n, p, K, dtype=\"float64\"):\n", + " super(AONet, self).__init__()\n", + "\n", + " self.p = p\n", + " self.num_qubits = n * K\n", + " self.theta = self.create_parameter(shape=[self.p, self.num_qubits, 3],\n", + " default_initializer=paddle.nn.initializer.Uniform(low=0, high=2 * np.pi),\n", + " dtype=dtype, is_bias=False)\n", + "\n", + " def forward(self, hamiltonian):\n", + " \"\"\"\n", + " Forward propagation\n", + " \"\"\"\n", + " # Define a circuit with complex entangled layers\n", + " cir = UAnsatz(self.num_qubits)\n", + " cir.complex_entangled_layer(self.theta, self.p)\n", + " # Run the quantum circuit\n", + " cir.run_state_vector()\n", + " # Calculate the loss function\n", + " loss = cir.expecval(hamiltonian)\n", + "\n", + " return loss, cir" + ], + "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:00:16.258893Z", + "start_time": "2021-05-17T08:00:16.241066Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "### Training the quantum neural network\n", + "\n", + "After defining the quantum neural network, we use the gradient descent method to update the parameters to minimize the expectation value in Eq. (6). " + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 5, + "source": [ + "SEED = 100 # Set a global RNG seed \n", + "p = 1 # Number of layers in the quantum circuit\n", + "ITR = 120 # Number of training iterations\n", + "LR = 0.4 # Learning rate of the optimization method based on gradient descent" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "Here, we optimize the network defined above in PaddlePaddle." + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 7, + "source": [ + "# Fix paddle random seed\n", + "paddle.seed(SEED)\n", + "\n", + "# Building Quantum Neural Networks\n", + "net = AONet(n, p, K)\n", + "\n", + "# Use Adam optimizer\n", + "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters())\n", + "# Gradient descent iteration\n", + "for itr in range(1, ITR + 1):\n", + " # Run the network defined above\n", + " loss, cir = net(hamiltonian)\n", + " # Calculate the gradient and optimize\n", + " loss.backward()\n", + " opt.minimize(loss)\n", + " opt.clear_grad()\n", + " if itr % 10 == 0:\n", + " print(\"iter: \", itr, \" loss: \", \"%.4f\"% loss.numpy())" + ], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "iter: 10 loss: 0.4704\n", + "iter: 20 loss: 0.1302\n", + "iter: 30 loss: -0.2744\n", + "iter: 40 loss: -0.4700\n", + "iter: 50 loss: -0.5512\n", + "iter: 60 loss: -0.5684\n", + "iter: 70 loss: -0.5821\n", + "iter: 80 loss: -0.5833\n", + "iter: 90 loss: -0.5843\n", + "iter: 100 loss: -0.5847\n", + "iter: 110 loss: -0.5849\n", + "iter: 120 loss: -0.5849\n" + ] + } + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### Decoding the quantum solution\n", + "\n", + "After obtaining the minimum value of the loss function and the corresponding set of parameters $\\vec{\\theta}^*$, our task has not been completed. In order to obtain an approximate solution to the arbitrage opportunity optimization problem, it is necessary to decode the solution to the classical optimization problem from the quantum state $|\\vec{\\theta}^*\\rangle$ output by the circuit. To decode a quantum state, we need to measure it and then calculate the probability distribution of the measurement results, where a measurement result is a bit string that represents an answer for the arbitrage opportunity optimization problem: \n", + "\n", + "$$\n", + "p(z) = |\\langle z|\\vec{\\theta}^*\\rangle|^2.\n", + "\\tag{6}\n", + "$$\n", + "\n", + "In the case of quantum parameterized circuits with sufficient expressiveness, the greater the probability of a certain bit string is, the greater the probability that it corresponds to an optimal solution of arbitrage opportunity optimization problem.\n", + "\n", + "Paddle Quantum provides a function to read the probability distribution of the measurement results of the state output by the quantum circuit:" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 8, + "source": [ + "# Repeat the simulated measurement of the circuit output state 1024 times\n", + "prob_measure = cir.measure(shots=1024)\n", + "arbitrage_opportunity_route = max(prob_measure, key=prob_measure.get)\n", + "print(\"The bit string form of the solution:\", arbitrage_opportunity_route)" + ], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "The bit string form of the solution: 100001010\n" + ] + } + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "After measurement, we have found the bit string with the highest probability of occurrence, i.e. the most profitable cycle in the form of the bit string. The binary strings are grouped every $n$ bits, and $1$ appearing at the $k$th bit in each group indicates the order that the asset is traded into this market. If the result is not valid as explained before, users can get better training results by adjusting parameters such as the random seed ``SEED``, the number of layers of the quantum circuit ``p``, the number of iterations ``ITR`` and the gradient descent optimization rate ``LR``.\n", + "\n", + "The following code maps the bit string back to the classic solution in the form of `dictionary`, where the `key` represents the vertex currency and the `value` represents its order, i.e. when the asset is traded into this market.\n", + "\n", + "Also, we calculated the positive return of the asset after the optimal arbitrage cycle." + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 9, + "source": [ + "solution = {nodes[i]:t for i in range(n) for t in range(n) if arbitrage_opportunity_route[i * n + t] == '1'}\n", + "print(solution)\n", + "rate = sum([np.log2(G[u][v][\"weight\"]) if solution[v] == (solution[u] + 1) % n else 0 for (u, v) in G.edges])\n", + "print(\"Positive return rate: \", 2**rate)" + ], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "{'JPY': 0, 'CNY': 2, 'USD': 1}\n", + "Positive return rate: 1.5\n" + ] + } + ], + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:02:14.554317Z", + "start_time": "2021-05-17T08:02:14.500593Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "In order to clearly represent the most profitable cycle of the assets, a graphical representation is still chosen:\n", + "* The numbers in the vertices represent the order of the transaction to this market and the letters represent currencies\n", + "\n", + "* The red edges represent the found optimal route." + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 10, + "source": [ + "label_dict = {i: str(i) + \", \" + str(t) for i, t in solution.items()}\n", + "edge_color1 = [\"red\" if solution[v] == (solution[u] + 1) % n else \"black\"\n", + " for (u, v) in G1.edges]\n", + "edge_color2 = [\"red\" if solution[v] == (solution[u] + 1) % n else \"black\"\n", + " for (u, v) in G2.edges]\n", + "\n", + "# Draw the optimal arbitrage cycle on the graph\n", + "fig, ax = plt.subplots(1, 2, figsize=(15, 4))\n", + "for i, a in enumerate(ax):\n", + " a.axis('off')\n", + " a.margins(0.20)\n", + "nx.draw(G1, pos=nx.circular_layout(G1), labels=label_dict, edge_color=edge_color1, ax=ax[0], **options)\n", + "nx.drawing.nx_pylab.draw_networkx_edge_labels(G1, pos=nx.circular_layout(G1), ax=ax[0], edge_labels=nx.get_edge_attributes(G1, 'weight'))\n", + "nx.draw(G2, pos=nx.circular_layout(G2), labels=label_dict, edge_color=edge_color2, ax=ax[1], **options)\n", + "nx.drawing.nx_pylab.draw_networkx_edge_labels(G2, pos=nx.circular_layout(G2), ax=ax[1], edge_labels=nx.get_edge_attributes(G2, 'weight'))\n", + "plt.axis(\"off\")\n", + "plt.show()" + ], + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {} + } + ], + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:02:14.571954Z", + "start_time": "2021-05-17T08:02:14.559634Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "The left graph given above shows the edge that is not in the arbitrage cycle, and the right graph shows the optimal solution found by the algorithm." + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### Conclusion\n", + "\n", + "In this tutorial, we provide a way to approximate a cycle of transactions with the maximum positive return in the arbitrage opportunity problem. For $n$ currencies, we need to use $n^2$ qubits for the optimization. We assign special values to exchange rates for testing, and users can assign those values themselves, i.e. according to the current market.\n", + "\n", + "In real financial markets, high return as $1.5$ in this tutorial on arbitrage is not usually available. Also, the number of currencies considered would be large with more influencing factors. This would be hard to implement. " + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "_______\n", + "\n", + "## References\n", + "\n", + "[1] Orus, Roman, Samuel Mugel, and Enrique Lizaso. \"Quantum computing for finance: Overview and prospects.\" [Reviews in Physics 4 (2019): 100028.](https://arxiv.org/abs/1807.03890)\n", + "\n", + "[2] Egger, Daniel J., et al. \"Quantum computing for Finance: state of the art and future prospects.\" [IEEE Transactions on Quantum Engineering (2020).](https://arxiv.org/abs/2006.14510)\n", + "\n", + "[3] Rosenberg, G. \"Finding optimal arbitrage opportunities using a quantum annealer.\" [1QB Information Technologies Write Paper (2016): 1-7.](https://1qbit.com/whitepaper/arbitrage/)" + ], + "metadata": {} + } + ], + "metadata": { + "interpreter": { + "hash": "3b61f83e8397e1c9fcea57a3d9915794102e67724879b24295f8014f41a14d85" + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3.7.11 64-bit ('pq_env': conda)" + }, + "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.7.11" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} \ No newline at end of file diff --git a/tutorial/combinatorial_optimization/PortfolioDiversification_CN.ipynb b/tutorial/combinatorial_optimization/PortfolioDiversification_CN.ipynb new file mode 100644 index 0000000..c54d5d3 --- /dev/null +++ b/tutorial/combinatorial_optimization/PortfolioDiversification_CN.ipynb @@ -0,0 +1,473 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "source": [ + "# 量子金融应用：投资组合分散化\n", + "\n", + " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "## 概览\n", + "\n", + "当前量子计算应用到金融问题上的解决方案通常可分为三类量子算法，即量子模拟，量子优化以及量子机器学习 [1,2]。许多的金融问题本质上是一个组合优化问题，解决这些问题的算法通常具有较高的时间复杂度，实现难度较大。得益于量子计算强大的计算性能，未来有望通过量子算法解决这些复杂问题。\n", + "\n", + "量桨的 Quantum Finance 模块主要讨论的是量子优化部分的内容，即如何通过一些量子算法解决实际金融应用中的优化问题。本文主要介绍如何使用量子算法求解被动投资管理中投资组合分散化问题。" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "## 投资组合分散化问题\n", + "\n", + "普通用户受专业知识和市场经验的不足的限制，在实际的投资中偏向于被动投资策略。指数投资就是一种常见的被动投资例子，比如说投资者长期购买并持有标普 $500$ 指数（Standard & Poor’s $500$）。作为投资人，假如你不想投资已有的指数，那么你也可以自己创建特定的指数投资组合，在市场中挑选合适的股票加入到创建的指数投资组合中。\n", + "\n", + "分散化是投资组合中平衡风险和收益的一个重要方法。对投资组合分散化的一个具体描述如下：当前可投资的股票数量为 $n$，指数投资组合中包含的股票数量为 $K$，需要对这 $n$ 个股票进行聚类，根据相似性将可选的股票划分为 $K$ 个类别，再从每个类别中选出最能代表该类别的股票，将其加入到指数组合中来，便于更好的控制风险，提高收益。" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### 编码投资组合分散化问题\n", + "\n", + "为了将投资组合分散化问题转化成一个参数化量子电路（parameterized quantum circuits, PQC）可解的问题，我们首先需要编码该问题的哈密顿量。\n", + "\n", + "在对该问题进行建模时，需要明确的有两个问题，第一是如何对不同的股票进行分类，第二便是以什么样的标准挑选代表性的股票。为了解决这两个问题，首先需要定义股票 $i$ 和股票 $j$ 之间的相似度 $\\rho_{ij}$:\n", + "* $\\rho_{ii} = 1 \\quad $ 该股票和其自身的相似度为1\n", + "* $\\rho_{ij} \\leq 1 \\quad$ 不同股票间 $\\rho_{ij}$ 越大，相似度越高\n", + "\n", + "由于两股票间收益率的相关性，我们可以在协方差矩阵基础上进一步对时间序列间的相似性进行度量。动态时间规整（Dynamic Time Warping, DTW）是一种常见的衡量两个时间序列之间相似度的方法，在本文中，采用DTW算法来计算两股票之间的相似性。基于该度量，我们可以对股票进行分类并挑选代表性股票。对于给定的 $n$ 支股票，每支股票我们可以定义 $n$ 个二进制变量 $x_{ij}$ 和 $1$ 个二进制变量 $y_j$。对于变量 $x_{ij}$，每 $n$ 位一组，$i$ 表示是第几支股票，$j$ 表示在该股票对应的 $n$ 个二进制变量中的序号。每支股票的 $n$ 位二进制变量如果相同位置为 $1$ (即 $j$ 相同)，则说明这两只股票被分为同一类，其中 $i = j$ 的就是该类别中被选到指数组合中的最具代表性的股票：\n", + "\n", + "$$\n", + "x_{ij}=\n", + "\\begin{cases}\n", + "1, & \\text{指数组合中的股票 $j$ 和股票 $i$ 具有最高的相似度}\\\\\n", + "0, & \\text{其他情况}\n", + "\\end{cases},\n", + "$$\n", + "\n", + "$$\n", + "y_{j}=\n", + "\\begin{cases}\n", + "1, & \\text{某类中的代表性股票 $j$ 被选择到指数组合中}\\\\\n", + "0, & \\text{其他情况}\n", + "\\end{cases}.\n", + "$$\n", + "\n", + "在该问题中我们的模型便可以写作：\n", + "\n", + "$$\n", + "\\mathcal{M}= \\max_{x_{ij}}\\sum_{i=1}^n\\sum_{j=1}^n \\rho_{ij}x_{ij}. \\tag{1}\n", + "$$\n", + "\n", + "该模型需要满足以下几类约束：\n", + "* 聚类约束：限制指数组合中只能有 $K$ 支股票\n", + " - $ \\sum_{j=1}^n y_j = K$\n", + "* 整数约束：限制一只股票要么是在指数组合中，要么就不在\n", + " - $ x_{ij},y_j\\in{\\{0,1\\}}, \\forall i = 1, \\dots,n; j = 1, \\dots, n$\n", + "* 一致性约束：保证如果一只股票可以代表另一支股票，那么它必须在指数组合中\n", + " - $\\sum_{j=1}^n x_{ij} = 1, \\forall i = 1,\\dots,n$\n", + " - $x_{ij} \\leq y_j, \\forall i = 1,\\dots,n; j = 1,\\dots, n$\n", + " - $x_{jj} = y_j, \\forall j = 1,\\dots,n$\n", + "\n", + "该模型目标就是让可选择的 $n$ 个股票与挑选的指数股票组合间相似性最大化。\n", + "\n", + "由于要对代价函数做梯度下降优化，所以在定义时就根据模型方程和相应的约束条件做一定修改：\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "C_x &= -\\sum_{i=1}^{n}\\sum_{j=1}^{n}\\rho_{ij}x_{ij} + A\\left(K- \\sum_{j=1}^n y_j \\right)^2 + \\sum_{i=1}^n A\\left(\\sum_{j=1}^n 1- x_{ij} \\right)^2 \\\\\n", + "&\\quad + \\sum_{j=1}^n A\\left(x_{jj} - y_j\\right)^2 + \\sum_{i=1}^n \\sum_{j=1}^n A\\left(x_{ij}(1 - y_j)\\right).\\\\ \n", + "\\end{aligned} \\tag{2}\n", + "$$ \n", + "\n", + "该式子中第一项为相似性最大化，后面四项均为约束条件，$A$ 为惩罚参数，通常设置为较大的数字，使得最终表示指数投资组合结果的二进制字符串满足约束条件。\n", + "\n", + "现在我们需要将代价函数转为一个哈密顿量，从而完成投资组合分散化问题的编码。每一个二进制变量可以取0和1两个值，分别对应量子态 $|0\\rangle$ 和 $|1\\rangle$。每个二进制变量都对应一个量子比特，所以我们需要 $n^2 + n$ 个量子比特来解决投资组合分散化问题。因为我们的变量 $x_{ij}$ 的值为 $0$ 和 $1$，所以我们要构造一个本征值和它对应的哈密顿量。泡利 $Z$ 的本征值为 $\\pm 1$，于是我们构造的哈密顿量为 $\\frac{I-Z}{2}$，对应的本征值即为 $0$ 和 $1$。\n", + "\n", + "我们现在将二进制变量映射到泡利 $Z$ 矩阵上，从而使 $C_x$ 转化成哈密顿矩阵：\n", + "\n", + "$$\n", + "x_{ij} \\mapsto \\frac{I-Z_{ij}}{2}, \\tag{3}\n", + "$$\n", + "\n", + "这里 $Z_{ij} = I \\otimes I \\otimes \\ldots \\otimes Z \\otimes \\ldots \\otimes I$，也就是说 $Z$ 作用在 $ij$ 的量子比特上。通过这个映射，如果一个编号为 $ij$ 的量子比特的量子态为 $|1\\rangle$，那么对应的二进制变量的取值为 $x_{ij} |1\\rangle = \\frac{I-Z_{ij}}{2} |1\\rangle = 1|1\\rangle $，也就是说该项目是我们要投资的。同样地，对于量子态为 $|0\\rangle$的量子比特 $i$，它所对应的二进制变量的取值为 $x_{ij}|0\\rangle = \\frac{I-Z_{ij}}{2} |0\\rangle = 0 |0\\rangle $。\n", + "\n", + "我们用上述映射将 $C_x$ 转化成量子比特数为 $n^2+n$ 的系统的哈密顿矩阵 $H_C$（其中 $x_{ij}$ 占 $n^2$ 个qubit，$y_j$ 占 $n$ 个 qubit），从而实现了投资组合分散化问题的量子化。这个哈密顿矩阵 $H_C$ 的基态即为投资组合分散化问题的最优解。在接下来的部分，我们将展示如何用参数化量子电路找到这个矩阵的基态，也就是对应最小本征值的本征态。" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "## Paddle Quantum 实现\n", + "\n", + "要在量桨上实现用参数化量子电路解决量子金融中的投资组合分散化问题，首先要做的便是加载需要用到的包。" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 1, + "source": [ + "#加载额外需要的包\n", + "import numpy as np\n", + "import pandas as pd\n", + "import datetime\n", + "\n", + "#加载飞桨，量桨相关的模块\n", + "import paddle\n", + "from paddle_quantum.circuit import UAnsatz\n", + "from paddle_quantum.finance import DataSimulator\n", + "from paddle_quantum.finance import portfolio_diversification_hamiltonian" + ], + "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:00:15.901429Z", + "start_time": "2021-05-17T08:00:12.708945Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "### 准备实验数据\n", + "\n", + "和投资组合优化问题相似，在本问题中，我们选定的投资项目类型为股票。对于实验测试要用的数据，提供了两种方法：\n", + "* 第一种是根据一定的条件，随机生成数据。\n", + "\n", + "如果采用这种方法准备实验数据，用户在初始化数据时，就需要给出可投资股票的名字列表，交易数据的开始日期和结束日期。" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 2, + "source": [ + "num_assets = 3 #可选择股票数目\n", + "stocks = [(\"TICKER%s\" % i) for i in range(num_assets)]\n", + "data = DataSimulator( stocks = stocks, start = datetime.datetime(2016, 1, 1), end = datetime.datetime(2016, 1, 30)) # 根据指定的条件，随机生成测试所需的数据" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "* 第二种是用户可以选择读取本地收集到的真实数据集用于实验。考虑到文件中包含的股票数可能会很多，用户可以指定用于该实验的股票数量，即 上面初始化的`num_assets`。\n", + "\n", + "我们收集了 $12$ 支股票 $35$ 个交易日的收盘价格存放到 `realStockData_12.csv` 文件中，在这里我们只选择读取前 $3$ 个股票的信息。\n", + "\n", + "在本教程中，我们选择读取的真实数据作为实验数据。" + ], + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:00:16.212260Z", + "start_time": "2021-05-17T08:00:15.918792Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 3, + "source": [ + "df = pd.read_csv('realStockData_12.csv')\n", + "dt = []\n", + "for i in range(num_assets):\n", + " mylist = df['closePrice'+str(i)].tolist()\n", + " dt.append(mylist)\n", + "print(dt) # 输出从文件中读取的3个股票在35个交易日中的收盘价格\n", + "\n", + "data.set_data(dt) # 指定实验数据为用户读取的数据" + ], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "[[16.87, 17.18, 17.07, 17.15, 16.66, 16.79, 16.69, 16.99, 16.76, 16.52, 16.33, 16.39, 16.45, 16.0, 16.09, 15.54, 13.99, 14.6, 14.63, 14.77, 14.62, 14.5, 14.79, 14.77, 14.65, 15.03, 15.37, 15.2, 15.24, 15.59, 15.58, 15.23, 15.04, 14.99, 15.11, 14.5], [32.56, 32.05, 31.51, 31.76, 31.68, 32.2, 31.46, 31.68, 31.39, 30.49, 30.53, 30.46, 29.87, 29.21, 30.11, 28.98, 26.63, 27.62, 27.64, 27.9, 27.5, 28.67, 29.08, 29.08, 29.95, 30.8, 30.42, 29.7, 29.65, 29.85, 29.25, 28.9, 29.33, 30.11, 29.67, 29.59], [5.4, 5.48, 5.46, 5.49, 5.39, 5.47, 5.46, 5.53, 5.5, 5.47, 5.39, 5.35, 5.37, 5.24, 5.26, 5.08, 4.57, 4.44, 4.5, 4.56, 4.52, 4.59, 4.66, 4.67, 4.66, 4.72, 4.84, 4.81, 4.84, 4.88, 4.89, 4.82, 4.74, 4.84, 4.79, 4.63]]\n" + ] + } + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### 编码哈密顿量\n", + "\n", + "这里我们将式（2）中的二进制变量用式（3）替换，从而构建哈密顿量 $H_C$。" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "在编码哈密顿量的过程中，首先需要计算各股票之间的相似矩阵 $\\rho$。" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 4, + "source": [ + "rho = data.get_similarity_matrix()" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "根据计算的相似矩阵和给定的参数构建哈密顿量。" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 5, + "source": [ + "q = 2 # 指数组合中需要的股票数目\n", + "penalty = num_assets # 惩罚参数：不小于可投资股票的数目\n", + "hamiltonian = portfolio_diversification_hamiltonian(penalty, rho, q)" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### 计算损失函数\n", + "\n", + "调用量桨内置的 [`complex entangled layer`](https://qml.baidu.com/api/paddle_quantum.circuit.uansatz.html) 构造参数化量子电路。该电路会返回一个输出态 $|\\vec{\\theta}\\rangle$，由此输出态，我们可以定义投资组合分散化问题在经典-量子混合模型下的损失函数：\n", + "\n", + "$$\n", + "L(\\vec{\\theta}) = \\langle\\vec{\\theta}|H_C|\\vec{\\theta}\\rangle.\n", + "\\tag{4}\n", + "$$\n", + "\n", + "之后我们利用经典的优化算法寻找最优参数 $\\vec{\\theta}^*$。下面的代码给出了通过量桨和飞桨搭建网络的过程。" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 6, + "source": [ + "class PDNet(paddle.nn.Layer):\n", + "\n", + " def __init__(self, n, p, dtype=\"float64\"):\n", + " super(PDNet, self).__init__()\n", + "\n", + " self.p = p\n", + " self.num_qubits = n * (n+1)\n", + " self.theta = self.create_parameter(shape=[self.p, self.num_qubits, 3],\n", + " default_initializer=paddle.nn.initializer.Uniform(low=0, high=2 * np.pi),\n", + " dtype=dtype, is_bias=False)\n", + " # print(self.theta)\n", + "\n", + " def forward(self, hamiltonian):\n", + " \"\"\"\n", + " 前向传播\n", + " \"\"\"\n", + " cir = UAnsatz(self.num_qubits)\n", + " cir.complex_entangled_layer(self.theta, self.p)\n", + " cir.run_state_vector()\n", + " loss = cir.expecval(hamiltonian)\n", + "\n", + " return loss, cir" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### 训练量子神经网络\n", + "\n", + "定义好了量子神经网络后，我们使用梯度下降的方法来更新其中的参数，使得式（4）的期望值最小。" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 7, + "source": [ + "SEED = 1100 # 随机数种子\n", + "p = 2 # 量子电路的层数\n", + "ITR = 150 # 迭代次数\n", + "LR = 0.4 # 梯度下降优化速率 " + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "使用飞桨，优化上面定义的网络。" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 8, + "source": [ + "# 比特数量\n", + "n = len(rho)\n", + "\n", + "# 固定随机数种子\n", + "paddle.seed(SEED)\n", + "\n", + "# 定义量子神经网络\n", + "net = PDNet(n, p)\n", + "\n", + "# 使用 Adam 优化器\n", + "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters())\n", + "\n", + "# 梯度下降优化循环\n", + "for itr in range(1, ITR + 1):\n", + " loss, cir = net(hamiltonian)\n", + " loss.backward()\n", + " opt.minimize(loss)\n", + " opt.clear_grad()\n", + " if itr % 10 == 0:\n", + " print(\"循环数:\", itr, \" 损失:\", \"%.4f\"% loss.numpy())" + ], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "循环数: 10 损失: 7.7804\n", + "循环数: 20 损失: 5.4414\n", + "循环数: 30 损失: 3.6022\n", + "循环数: 40 损失: 3.2910\n", + "循环数: 50 损失: 1.9358\n", + "循环数: 60 损失: 0.3872\n", + "循环数: 70 损失: 0.1344\n", + "循环数: 80 损失: 0.0774\n", + "循环数: 90 损失: 0.0122\n", + "循环数: 100 损失: 0.0068\n", + "循环数: 110 损失: -0.0001\n", + "循环数: 120 损失: -0.0019\n", + "循环数: 130 损失: -0.0025\n", + "循环数: 140 损失: -0.0028\n", + "循环数: 150 损失: -0.0028\n" + ] + } + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### 解码量子答案\n", + "\n", + "当调用优化器求得损失函数的最小值以及相对应的一组参数 $\\vec{\\theta}^*$后，为了进一步求得投资组合优化问题的近似解，需要从电路输出的量子态 $|\\vec{\\theta}^*\\rangle$ 中解码出经典优化问题的答案。物理上，解码量子态需要对量子态进行测量，然后统计测量结果的概率分布：\n", + "\n", + "$$\n", + "p(z) = |\\langle z|\\vec{\\theta}^*\\rangle|^2.\n", + "\\tag{6}\n", + "$$\n", + "\n", + "在量子参数化电路表达能力足够的情况下，某个比特串出现的概率越大，意味着其是投资组合优化问题最优解的可能性越大。\n", + "\n", + "量桨提供了查看参数化量子电路输出状态的测量结果概率分布的函数。" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 14, + "source": [ + "# 模拟重复测量电路输出态 2048 次\n", + "prob_measure = cir.measure(shots=2048)\n", + "investment = max(prob_measure, key=prob_measure.get)\n", + "print(\"利用哈密顿量找到的解的比特串形式：\", investment)" + ], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "利用哈密顿量找到的解的比特串形式： 100001001101\n" + ] + } + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "我们的测量结果是表示投资组合分散化问题答案的比特串：如上文结果 ``100001001101``，我们一共有 $n = 3$ 支可投资股票，选择两只到指数组合中。前 $n^2 = 9$ 位 ``100001001`` 代表 $x_{ij}$，每 $3$ 位为一组，第一组 ``100`` 中第一位为 $1$，代表它被划作一类。第二组 ``001`` 和第三组 ``001`` 中第三位被置为 $1$，代表它们被划为一类。同时，第一组和第三组 $1$ 出现的位置符合 $i = j$，即这两支股票为最能代表各自类的股票。另外，可以看出 $1$ 出现的位置是 $j = 1$ 和 $j = 3$，即两个位置可能为 $1$，这和我们预设的指数组合中有两只股票是对应的。同时，后 $3$ 位为 ``101``，代表 $y_j$, 表示第一支股票和第三支股票被选中放入指数组合中。通过上述说明，可以看出我们求解得到的结果是一个有效解。如果最后的结果不是上述这种有效解，读者依然可以通过调整参数化量子电路的参数值，来获得更好的训练效果。" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### 结语\n", + "\n", + "在本教程中，我们主要讨论了分散化投资中如何对可投资项目进行分类，以及如何挑选具有代表性的到我们的投资组合中来。在本问题中，每个投资项目都需要 $n$ 位量子比特来表示分类，$1$ 位量子比特表示是否被选中。受量子比特数目的限制，目前能够处理的投资项目数还比较少。" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "_______\n", + "\n", + "## 参考文献\n", + "\n", + "[1] Orus, Roman, Samuel Mugel, and Enrique Lizaso. \"Quantum computing for finance: Overview and prospects.\" [Reviews in Physics 4 (2019): 100028.](https://arxiv.org/abs/1807.03890)\n", + "\n", + "[2] Egger, Daniel J., et al. \"Quantum computing for Finance: state of the art and future prospects.\" [IEEE Transactions on Quantum Engineering (2020).](https://arxiv.org/abs/2006.14510)" + ], + "metadata": {} + } + ], + "metadata": { + "interpreter": { + "hash": "3b61f83e8397e1c9fcea57a3d9915794102e67724879b24295f8014f41a14d85" + }, + "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.7.10" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} \ No newline at end of file diff --git a/tutorial/combinatorial_optimization/PortfolioDiversification_EN.ipynb b/tutorial/combinatorial_optimization/PortfolioDiversification_EN.ipynb new file mode 100644 index 0000000..11dd4e4 --- /dev/null +++ b/tutorial/combinatorial_optimization/PortfolioDiversification_EN.ipynb @@ -0,0 +1,479 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "source": [ + "# Quantum Finance Application: Portfolio Diversification\n", + "\n", + " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "## Overview\n", + "\n", + "Current finance problem can be mainly tackled by three areas of quantum algorithms: quantum simulation, quantum optimization, and quantum machine learning [1,2]. Many financial problems are essentially a combinatorial optimization problem, and corresponding algorithms usually have high time complexity and are difficult to implement. Due to the power of quantum computing, these complex problems are expected to be solved by quantum algorithms in the future.\n", + "\n", + "The Quantum Finance module of Paddle Quantum focuses on quantum optimization: how to apply quantum algorithms in real finance optimization problems. This tutorial focuses on how to use quantum algorithms to solve the portfolio diversification problem." + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "## Portfolio Diversification Problem\n", + "\n", + "Limited by the lack of professional knowledge and market experience, the investor prefers a passive investment strategy in the actual investment. Index investing is a typical example of passive investing, e.g. an investor buys and holds the Standard & Poor’s 500 (S&P 500) for a long period of time. As an investor, if you do not want to invest an existing index portfolio, you can also create your own specific index portfolio by picking representative stocks from the market.\n", + "\n", + "An important way to balance risk and return in an investment portfolio is to diversify your assets. A specific description of portfolio diversification is as follows: the number of investable stocks is $n$ and the number of stocks included in the portfolio is $K$. Based on some criteria, you need to divide all the stocks into $K$ categories and select the stock from each category that best represent that category. Adding representatives of each category to the index portfolio is better for investment management." + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### Encoding Portfolio Diversification Problem\n", + "\n", + "To transform the portfolio diversification problem into a problem applicable for parameterized quantum circuits, we need to encode portfolio diversification problem into a Hamiltonian.\n", + "\n", + "To model the problem, two issues need to be clarified. The first one is how to classify different stocks, and the second one is what criteria are used to select representative stocks. To solve these two problems, firstly we define the similarity $\\rho_{ij}$ between stock $i$ and stock $j$:\n", + "* $\\rho_{ii} = 1 \\quad $ The stock is similar to itself with a similarity of 1 \n", + "* $\\rho_{ij} \\leq 1 \\quad$ The larger $\\rho_{ij}$ , the higher the similarity between stock $i$ and stock $j$\n", + "\n", + "Due to the correlation of returns between stocks, we can further measure the similarity between the time series on the basis of the covariance matrix. Dynamic Time Warping (DTW) is a common method to measure the similarity of two time series. In this paper, the DTW algorithm is used to calculate the similarity between two stocks. So based on the similarity between different stocks, we can classify the stocks and select representative stock in each category. We can define $n$ binary variables $x_{ij}$ and $1$ binary variables $y_j$ for each stock. Therefore, given $n$ stocks, there are $n^2 + n$ binary variables. For the variable $x_{ij}$, $i$ denotes the order of stock, and $j$ denotes the position among the $n$ binary variables corresponding to that stock. If two stock has same index of $j$, they are classified in the same category. Meanwhile, the stock of $i = j$ is the most representative one in that category selected to the index portfolio:\n", + "\n", + "$$\n", + "x_{ij}=\n", + "\\begin{cases}\n", + "1, & \\text{stock $j$ is in the portfolio and it has the highest similarity to stock $i$}\\\\\n", + "0, & \\text{otherwise}\n", + "\\end{cases},\n", + "$$\n", + "\n", + "$$\n", + "y_{j}=\n", + "\\begin{cases}\n", + "1, & \\text{stock $j$ is selected to the index portfolio}\\\\\n", + "0, & \\text{otherwise}\n", + "\\end{cases}.\n", + "$$\n", + "\n", + "The model can be written as follows:\n", + "\n", + "$$\n", + "\\mathcal{M}= \\max_{x_{ij}}\\sum_{i=1}^n\\sum_{j=1}^n \\rho_{ij}x_{ij}. \\tag{1}\n", + "$$\n", + "\n", + "The model needs to satisfy the following constraints:\n", + "* Clustering constraint: the index portfolio only include $K$ stocks\n", + " - $ \\sum_{j=1}^n y_j = K$\n", + "* Integer constraint: a stock is either in the index portfolio or not\n", + " - $ x_{ij},y_j\\in{\\{0,1\\}}, \\forall i = 1, \\dots,n; j = 1, \\dots, n$\n", + "* Consistency constraint: if a stock can represent another stock, it must be in the index portfolio\n", + " - $\\sum_{j=1}^n x_{ij} = 1, \\forall i = 1,\\dots,n$\n", + " - $x_{ij} \\leq y_j, \\forall i = 1,\\dots,n; j = 1,\\dots, n$\n", + " - $x_{jj} = y_j, \\forall j = 1,\\dots,n$\n", + "\n", + "The objective of the model is to maximize the similarity between the $n$ stocks and the selected index stock portfolio.\n", + "\n", + "Since the loss function is to be optimized using the gradient descent method, some modifications are made in the loss function based on the the model equation and constrains:\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "C_x &= -\\sum_{i=1}^{n}\\sum_{j=1}^{n}\\rho_{ij}x_{ij} + A\\left(K- \\sum_{j=1}^n y_j \\right)^2 + \\sum_{i=1}^n A\\left(\\sum_{j=1}^n 1- x_{ij} \\right)^2 \\\\\n", + "&\\quad + \\sum_{j=1}^n A\\left(x_{jj} - y_j\\right)^2 + \\sum_{i=1}^n \\sum_{j=1}^n A\\left(x_{ij}(1 - y_j)\\right).\\\\ \n", + "\\end{aligned} \\tag{2}\n", + "$$ \n", + "\n", + "The first term represents the similarity maximization, the next four terms are constraints. $A$ is the penalty parameter, which is usually set to a larger number so that the final binary string representing the index portfolio results satisfies the constraints.\n", + "\n", + "We now need to transform the cost function $C_x$ into a Hamiltonian to realize the encoding of the portfolio diversification problem. Each variable $x_{ij}$ has two possible values, $0$ and $1$, corresponding to quantum states $|0\\rangle$ and $|1\\rangle$. Note that every variable corresponds to a qubit and so $n^2 + n$ qubits are needed for solving the portfolio diversification problem. The Pauli $Z$ operator has two eigenstates which are the same as the states $|0\\rangle$ and $|1\\rangle$ . Their corresponding eigenvalues are 1 and -1, respectively. So we consider encoding the cost function as a Hamiltonian using the pauli $Z$ matrix.\n", + "\n", + "Now we would like to consider the mapping\n", + "\n", + "$$\n", + "x_{ij} \\mapsto \\frac{I-Z_{ij}}{2}, \\tag{3}\n", + "$$\n", + "\n", + "where $Z_{ij} = I \\otimes I \\otimes \\ldots \\otimes Z \\otimes \\ldots \\otimes I$ with $Z$ operates on the qubit at position $ij$. Under this mapping, the value of $x_{ij}$ represent different meanings. If the qubit $ij$ is in state $|1\\rangle$, then $x_{ij} |1\\rangle = \\frac{I-Z_{ij}}{2} |1\\rangle = 1|1\\rangle $, which means stock $i$ is in index portfolio. Also, for the qubit $ij$ in state $|0\\rangle$, $x_{ij}|0\\rangle = \\frac{I-Z_{ij}}{2} |0\\rangle = 0 |0\\rangle $.\n", + "\n", + "Thus using the above mapping, we can transform the cost function $C_x$ into a Hamiltonian $H_C$ for the system of $n^2+n$ qubits and realize the quantumization of the portfolio diversification problem. Then the ground state of $H_C$ is the optimal solution to the portfolio diversification problem. In the following section, we will show how to use a parametrized quantum circuit to find the ground state, i.e., the eigenvector with the smallest eigenvalue." + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "## Paddle Quantum Implementation\n", + "\n", + "To investigate the portfolio diversification problem using Paddle Quantum, there are some required packages to import, which are shown below." + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 2, + "source": [ + "# Import packages needed\n", + "import numpy as np\n", + "import pandas as pd\n", + "import datetime\n", + "\n", + "# Import related modules from Paddle Quantum and PaddlePaddle\n", + "import paddle\n", + "from paddle_quantum.circuit import UAnsatz\n", + "from paddle_quantum.finance import DataSimulator\n", + "from paddle_quantum.finance import portfolio_diversification_hamiltonian" + ], + "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:00:15.901429Z", + "start_time": "2021-05-17T08:00:12.708945Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "### Prepare experimental data\n", + "\n", + "In this tutorial, we choose stocks as the investment assets. For the data used in the experimental tests, two options are provided:\n", + "* The first method is to generate random data according to certain requirements, e.g. number of assets.\n", + "\n", + "If the user prepares data using this method, then when initializing the data, it is necessary to give the list of parameters: a list of names of investable stocks (assets), the start date and end date of the trading data." + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 3, + "source": [ + "num_assets = 3 # Number of investable projects\n", + "stocks = [(\"TICKER%s\" % i) for i in range(num_assets)]\n", + "data = DataSimulator( stocks = stocks, start = datetime.datetime(2016, 1, 1),\n", + " end = datetime.datetime(2016, 1, 30)) " + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "* The second method is that the user can choose to set the data themselves, i.e. real stock data collected by themselves. Considering that the number of stocks contained in the file may be large, the user can specify the number of stocks used for this experiment, i.e. `num_assets` as initialized above.\n", + "\n", + "We collect the closing prices of $12$ stocks for $35$ trading days into the `realStockData_12.csv` file, where we choose to read only the first $3$ stocks.\n", + "\n", + "In this tutorial, we choose to read real data as experimental data." + ], + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:00:16.212260Z", + "start_time": "2021-05-17T08:00:15.918792Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 4, + "source": [ + "df = pd.read_csv('realStockData_12.csv') \n", + "dt = []\n", + "for i in range(num_assets):\n", + " mylist = df['closePrice'+str(i)].tolist()\n", + " dt.append(mylist)\n", + "# Output the closing price of the seven stocks read from the file for the 35 trading days\n", + "print(dt) \n", + "# Specify the experimental data as a local file read by the user\n", + "data.set_data(dt) " + ], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "[[16.87, 17.18, 17.07, 17.15, 16.66, 16.79, 16.69, 16.99, 16.76, 16.52, 16.33, 16.39, 16.45, 16.0, 16.09, 15.54, 13.99, 14.6, 14.63, 14.77, 14.62, 14.5, 14.79, 14.77, 14.65, 15.03, 15.37, 15.2, 15.24, 15.59, 15.58, 15.23, 15.04, 14.99, 15.11, 14.5], [32.56, 32.05, 31.51, 31.76, 31.68, 32.2, 31.46, 31.68, 31.39, 30.49, 30.53, 30.46, 29.87, 29.21, 30.11, 28.98, 26.63, 27.62, 27.64, 27.9, 27.5, 28.67, 29.08, 29.08, 29.95, 30.8, 30.42, 29.7, 29.65, 29.85, 29.25, 28.9, 29.33, 30.11, 29.67, 29.59], [5.4, 5.48, 5.46, 5.49, 5.39, 5.47, 5.46, 5.53, 5.5, 5.47, 5.39, 5.35, 5.37, 5.24, 5.26, 5.08, 4.57, 4.44, 4.5, 4.56, 4.52, 4.59, 4.66, 4.67, 4.66, 4.72, 4.84, 4.81, 4.84, 4.88, 4.89, 4.82, 4.74, 4.84, 4.79, 4.63]]\n" + ] + } + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### Encoding Hamiltonian\n", + "\n", + "Here we construct the Hamiltonian $H_C$ of Eq. (2) with the replacement in Eq. (3). " + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "In the process of encoding Hamiltonian, we first need to calculate the similarity matrix $\\rho$ between the returns of each stock, which is available in the ``finance`` module and can be called directly. " + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 5, + "source": [ + "rho = data.get_similarity_matrix()" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "Based on the provided and calculated parameters, the Hamiltonian is constructed below. Here we set the penalty parameter to the number of investable stocks.\n" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 6, + "source": [ + "q = 2 # Number of stocks in the index portfolio\n", + "penalty = num_assets # penalty parameter \n", + "hamiltonian = portfolio_diversification_hamiltonian(penalty, rho, q)" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### Calculating the loss function \n", + "\n", + "We adopt a parameterized quantum circuit consisting of $U_3(\\vec{\\theta})$ and $\\text{CNOT}$ gates, that can be constructed by calling the built-in function [`complex entangled layer`](https://qml.baidu.com/api/paddle_quantum.circuit.uansatz.html).\n", + "\n", + "After running the quantum circuit, we obtain the circuit output $|\\vec{\\theta\n", + "}\\rangle$. From the output state of the circuit we can calculate the objective function, and also the loss function of the portfolio diversification problem:\n", + "\n", + "$$\n", + "L(\\vec{\\theta}) = \\langle\\vec{\\theta}|H_C|\\vec{\\theta}\\rangle.\n", + "\\tag{4}\n", + "$$\n", + "\n", + "We then use a classical optimization algorithm to minimize this function and find the optimal parameters $\\vec{\\theta}^*$. The following code shows a complete network built with Paddle Quantum and PaddlePaddle." + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 7, + "source": [ + "class PDNet(paddle.nn.Layer):\n", + "\n", + " def __init__(self, n, p, dtype=\"float64\"):\n", + " super(PDNet, self).__init__()\n", + "\n", + " self.p = p\n", + " self.num_qubits = n * (n+1)\n", + " self.theta = self.create_parameter(shape=[self.p, self.num_qubits, 3],\n", + " default_initializer=paddle.nn.initializer.Uniform(low=0, high=2 * np.pi),\n", + " dtype=dtype, is_bias=False)\n", + " # print(self.theta)\n", + "\n", + " def forward(self, hamiltonian):\n", + " \"\"\"\n", + " Forward propagation\n", + " \"\"\"\n", + " cir = UAnsatz(self.num_qubits)\n", + " cir.complex_entangled_layer(self.theta, self.p)\n", + " cir.run_state_vector()\n", + " loss = cir.expecval(hamiltonian)\n", + "\n", + " return loss, cir" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### Training the quantum neural network\n", + "\n", + "After defining the quantum neural network, we use the gradient descent method to update the parameters to minimize the expectation value in Eq. (4). " + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 8, + "source": [ + "SEED = 1100 # Set a global RNG seed \n", + "p = 2 # Number of layers in the quantum circuit\n", + "ITR = 150 # Number of training iterations\n", + "LR = 0.4 # Learning rate of the optimization method based on gradient descent" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "Here, we optimize the network defined above in PaddlePaddle." + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 9, + "source": [ + "# number of qubits\n", + "n = len(rho)\n", + "\n", + "# Fix paddle random seed\n", + "paddle.seed(SEED)\n", + "\n", + "# Building Quantum Neural Networks\n", + "net = PDNet(n, p)\n", + "\n", + "# Use Adam optimizer\n", + "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters())\n", + "\n", + "# Gradient descent iteration\n", + "for itr in range(1, ITR + 1):\n", + " loss, cir = net(hamiltonian)\n", + " loss.backward()\n", + " opt.minimize(loss)\n", + " opt.clear_grad()\n", + " if itr % 10 == 0:\n", + " print(\"iter:\", itr, \" loss:\", \"%.4f\"% loss.numpy())\n" + ], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "iter: 10 loss: 7.7804\n", + "iter: 20 loss: 5.4414\n", + "iter: 30 loss: 3.6022\n", + "iter: 40 loss: 3.2910\n", + "iter: 50 loss: 1.9358\n", + "iter: 60 loss: 0.3872\n", + "iter: 70 loss: 0.1344\n", + "iter: 80 loss: 0.0774\n", + "iter: 90 loss: 0.0122\n", + "iter: 100 loss: 0.0068\n", + "iter: 110 loss: -0.0001\n", + "iter: 120 loss: -0.0019\n", + "iter: 130 loss: -0.0025\n", + "iter: 140 loss: -0.0028\n", + "iter: 150 loss: -0.0028\n" + ] + } + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### Decoding the quantum solution\n", + "\n", + "After obtaining the minimum value of the loss function and the corresponding set of parameters $\\vec{\\theta}^*$, our task has not been completed. In order to obtain an approximate solution to the portfolio diversification problem, it is necessary to decode the solution to the classical optimization problem from the quantum state $|\\vec{\\theta}^*\\rangle$ output by the circuit. Physically, to decode a quantum state, we need to measure it and then calculate the probability distribution of the measurement results:\n", + "\n", + "$$\n", + "p(z) = |\\langle z|\\vec{\\theta}^*\\rangle|^2.\n", + "\\tag{5}\n", + "$$\n", + "\n", + "In the case of quantum parameterized circuits with sufficient expressiveness, the greater the probability of a certain bit string, the greater the probability that it corresponds to an optimal solution of the portfolio diversification problem.\n", + "\n", + "Paddle Quantum provides a function to read the probability distribution of the measurement results of the state output by the quantum circuit:" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 11, + "source": [ + "# Repeat the simulated measurement of the circuit output state 1024 times\n", + "\n", + "prob_measure = cir.measure(shots=2048)\n", + "investment = max(prob_measure, key=prob_measure.get)\n", + "print(\"The bit string form of the solution: \", investment)" + ], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "The bit string form of the solution: 100001001101\n" + ] + } + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "After measurement, we have found the bit string with the highest probability of occurrence, the index portfolio in the form of the bit string. As the result above ``100001001101``, we have $n = 3$ investable stocks and choose two to the index portfolio。The first $n^2 = 9$ bits of ``100001001`` represent $x_{ij}$, and every $3$ bits are grouped together. The first bit of the first group of ``100`` is set to $1$, which means it is classified as a class. The third bit in the second group ``001`` and the third group ``001`` is set to $1$, which means they are classified as one class. Also, the positions of $1$ in the first and third groups are satisfied with $i = j$, i.e., these two stocks are the most representative stock of their respective classes. It can be seen that $1$ appears at $j = 1$ and $j = 3$, i.e., two positions are possible for $1$, which corresponds to our presumption of having two stocks in the index portfolio. \n", + "The last $3$ position is ``101``, which represents $y_j$, indicating that the first stock and the third stock are selected to the index portfolio. If the final result is not such a valid solution as described above, users can still get a better training result by adjusting the parameter values of the parameterized quantum circuit." + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### Conclusion\n", + "\n", + "In this tutorial, we focus on how to classify investable stocks and how to select representative ones to our portfolio. In this problem, each investment item requires $n$ qubits to represent the classification and $1$ qubit to represent whether it is selected to portfolio or not. Due to the limitation of the number of qubits, the number of investment items that can be handled is still small." + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "_______\n", + "\n", + "## References\n", + "\n", + "[1] Orus, Roman, Samuel Mugel, and Enrique Lizaso. \"Quantum computing for finance: Overview and prospects.\" [Reviews in Physics 4 (2019): 100028.](https://arxiv.org/abs/1807.03890)\n", + "\n", + "[2] Egger, Daniel J., et al. \"Quantum computing for Finance: state of the art and future prospects.\" [IEEE Transactions on Quantum Engineering (2020).](https://arxiv.org/abs/2006.14510)" + ], + "metadata": {} + } + ], + "metadata": { + "interpreter": { + "hash": "3b61f83e8397e1c9fcea57a3d9915794102e67724879b24295f8014f41a14d85" + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3.7.11 64-bit ('pq_env': conda)" + }, + "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.7.11" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} \ No newline at end of file diff --git a/tutorial/combinatorial_optimization/PortfolioOptimization_CN.ipynb b/tutorial/combinatorial_optimization/PortfolioOptimization_CN.ipynb new file mode 100644 index 0000000..4b0a84e --- /dev/null +++ b/tutorial/combinatorial_optimization/PortfolioOptimization_CN.ipynb @@ -0,0 +1,500 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "source": [ + "# 量子金融应用：投资组合优化\n", + "\n", + " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "\n", + "## 概览\n", + "\n", + "当前量子计算应用到金融问题上的解决方案通常可分为三类量子算法，即量子模拟，量子优化以及量子机器学习 [1,2]。许多的金融问题本质上是一个组合优化问题，解决这些问题的算法通常具有较高的时间复杂度，实现难度较大。得益于量子计算强大的计算性能，未来有望通过量子算法解决这些复杂问题。\n", + "\n", + "量桨的 Quantum Finance 模块主要讨论的是量子优化部分的内容，即如何通过一些量子算法解决实际金融应用中的优化问题。本文主要介绍如何使用量子算法求解主动投资管理中投资组合优化问题。" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "## 投资组合优化问题\n", + "\n", + "投资组合是金融投资的集合，比如股票、债权、现金等。投资组合优化是许多主动型投资管理者需要面对的问题，它需要从业者应用相关数学理论方法，根据目标收益和风险对一笔资金进行投资，以期在收益一定的情况下风险最小化或者是风险一定的情况下投资收益最大化。\n", + "\n", + "对投资组合优化的一个具体描述如下：假如你是一位资产管理人，想要将数额为 $K$ 的资金一次性投入到 $N$ 个可投资的项目中，各项目都有自己的投资回报率和风险，你的目标就是在考虑到市场影响和交易费用的的基础上找到一个最佳的投资组合空间，使得该笔资产以最优的投资方案实施。" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### 编码投资组合优化问题\n", + "\n", + "为了将投资组合优化问题转化成一个参数化量子电路（parameterized quantum circuits, PQC）可解的问题，我们首先需要编码该问题的哈密顿量。\n", + "为了方便建模实现，需要做两点假设对问题加以限制：\n", + "* 每个项目都是等额投资的，\n", + "* 给定的预算是投资一个项目金额的整数倍，且必须全部花完。\n", + "\n", + "在该计算模型中我们把对项目的投资金额单位化，即如果投资预算为 $3$，那么就要投 $3$ 个项目。因为实际的投资中，预算是有限的，而可投资的项目是很多的，所以在设定参数时也要注意可投资项目数是要大于预算的。\n", + "\n", + "在投资组合的基本理论中，投资组合的总体风险与项目间的协方差有关，而协方差与任意两项目的相关系数成正比。相关系数越小，其协方差就越小，投资组合的总体风险也就越小 [3]。\n", + "在这里我们采用均值方差组合优化的方法，给出该问题的建模方程：\n", + "\n", + "$$\n", + "\\omega = \\max _{x \\in\\{0,1\\}^{n}} \\mu^{T} x - q x^{T} S x \\quad\\quad \\tag{1}\n", + "\\text { subject to: } \\mathbb{1}^{T} x=B,\n", + "$$\n", + "\n", + "该式子中各符号代表的含义如下：\n", + "* $x\\in {\\{0,1\\}}^n$ 表示一个向量，其中每一个元素均为二进制变量，即如果资产 $i$ 被投资了，则 $x_i = 1$，如果没有被选择，则 $x_i = 0$ \n", + "* $\\mu \\in \\mathbb{R}^n$ 表示投资每个项目的预期回报率\n", + "* $S \\in \\mathbb{R}^{n \\times n}$ 表示各投资项目回报率之间的协方差矩阵\n", + "* $q > 0$ 表示做出该投资决定的风险系数\n", + "* $\\mathbb{1}$ 表示 $n$ 维值全为 $1$ 向量\n", + "* $B$ 代表投资预算,即我们可以投资的项目数\n", + "\n", + "\n", + "根据模型方程，可以给出损失函数：\n", + "\n", + "$$\n", + "C_x = q \\sum_i \\sum_j S_{ji}x_ix_j - \\sum_{i}x_i \\mu_i + A \\left(B - \\sum_i x_i\\right)^2, \\tag{2}\n", + "$$\n", + "\n", + "其中，$S_{ij}$ 表示协方差矩阵 $S$ 的内部元素。\n", + "\n", + "由于要对损失函数做梯度下降优化，所以在定义时就根据模型的方程做了一定修改：其中第一项为风险项，表示该笔投资的风险；第二项为投资收益项；$A$ 为惩罚参数，通常设置为一个较大的数字，该项限定一笔资金预算 $B$ 必须均匀的投入到不同的投资项目中。\n", + "\n", + "现在我们需要将损失函数转为一个哈密顿量，从而完成投资组合优化问题的编码。每一个二进制变量可以取 $0$ 和 $1$ 两个值，分别对应量子态 $|0\\rangle$ 和 $|1\\rangle$。每个二进制变量都对应一个量子比特，所以我们需要 $n$ 个量子比特来解决投资组合优化问题。\n", + "因为我们的变量 $x_i$ 的值为 $0$ 和 $1$，所以我们要构造一个本征值和它对应的哈密顿量。泡利 $Z$ 的本征值为 $\\pm 1$，于是我们构造的哈密顿量为 $\\frac{I-Z}{2}$， 对应的本征值即为 $0$ 和 $1$。我们现在将二进制变量映射到泡利 $Z$ 矩阵上，从而使 $C_x$ 转化成哈密顿矩阵：\n", + "\n", + "$$\n", + "x_{i} \\mapsto \\frac{I-Z_{i,}}{2}, \\tag{3}\n", + "$$\n", + "\n", + "这里 $Z_{i} = I \\otimes I \\otimes \\ldots \\otimes Z \\otimes \\ldots \\otimes I$，也就是说 $Z$ 作用在第 $i$ 个量子比特上。通过这个映射，如果一个编号为 $i$ 的量子比特的量子态为 $|1\\rangle$，那么对应的二进制变量的取值为 $x_{i} |1\\rangle = \\frac{I-Z_{i}}{2} |1\\rangle = 1|1\\rangle $，也就是说该项目是我们要投资的。同样地，对于量子态为 $|0\\rangle$的量子比特 $i$，它所对应的二进制变量的取值为 $x_{i}|0\\rangle = \\frac{I-Z_{i}}{2} |0\\rangle = 0 |0\\rangle $。\n", + "\n", + "我们用上述映射将 $C_x$ 转化成量子比特数为 $n$ 的系统的哈密顿矩阵 $H_C$，从而实现了投资组合优化问题的量子化。这个哈密顿矩阵 $H_C$ 的基态即为投资组合优化问题的最优解。在接下来的部分，我们将展示如何用参数化量子电路找到这个矩阵的基态，也就是对应最小本征值的本征态。" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "## Paddle Quantum 实现\n", + "\n", + "要在量桨上实现用参数化量子电路解决量子金融中的投资组合优化问题，首先要做的便是加载需要用到的包。" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 1, + "source": [ + "#加载需要的包\n", + "import numpy as np\n", + "import pandas as pd\n", + "import datetime\n", + "\n", + "#加载飞桨，量桨相关的模块\n", + "import paddle\n", + "from paddle_quantum.circuit import UAnsatz\n", + "from paddle_quantum.finance import DataSimulator, portfolio_optimization_hamiltonian" + ], + "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:00:15.901429Z", + "start_time": "2021-05-17T08:00:12.708945Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "### 准备实验数据\n", + "在本问题中，我们选定的投资项目为股票。对于实验测试要用的数据，提供了两种选择：\n", + "* 第一种方法是根据设定的条件，随机生成实验数据。\n", + "\n", + "如果采用这种方法准备数据，用户在初始化数据时，就需要给出可投资股票的名字列表，交易数据的开始日期和结束日期。" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 2, + "source": [ + "num_assets = 7 # 可投资的项目数量\n", + "stocks = [(\"STOCK%s\" % i) for i in range(num_assets)] \n", + "data = DataSimulator(stocks=stocks, start=datetime.datetime(2016, 1, 1), end=datetime.datetime(2016, 1, 30)) # 根据指定的条件，随机生成测试所需的数据\n", + "ds = data.randomly_generate()" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "* 第二种方法是用户可以选择读取本地收集到的真实数据集用于实验。考虑到文件中包含的股票数可能会很多，用户可以指定用于该实验的股票数量，即上面初始化的 `num_assets`。\n", + "\n", + "我们收集了 $12$ 支股票 $35$ 个交易日的收盘价格存放到 `realStockData_12.csv` 文件中，在这里我们只选择读取前 $7$ 个股票的信息。\n", + "\n", + "在本教程中，我们选择读取真实数据作为实验数据。" + ], + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:00:16.212260Z", + "start_time": "2021-05-17T08:00:15.918792Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 3, + "source": [ + "df = pd.read_csv('realStockData_12.csv')\n", + "dt = []\n", + "for i in range(num_assets): \n", + " mylist = df['closePrice'+str(i)].tolist()\n", + " dt.append(mylist) \n", + "print(dt) # 输出从文件中读取的七个股票在35个交易日中的收盘价格\n", + "\n", + "data.set_data(dt) # 指定实验数据为用户读取的数据" + ], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "[[16.87, 17.18, 17.07, 17.15, 16.66, 16.79, 16.69, 16.99, 16.76, 16.52, 16.33, 16.39, 16.45, 16.0, 16.09, 15.54, 13.99, 14.6, 14.63, 14.77, 14.62, 14.5, 14.79, 14.77, 14.65, 15.03, 15.37, 15.2, 15.24, 15.59, 15.58, 15.23, 15.04, 14.99, 15.11, 14.5], [32.56, 32.05, 31.51, 31.76, 31.68, 32.2, 31.46, 31.68, 31.39, 30.49, 30.53, 30.46, 29.87, 29.21, 30.11, 28.98, 26.63, 27.62, 27.64, 27.9, 27.5, 28.67, 29.08, 29.08, 29.95, 30.8, 30.42, 29.7, 29.65, 29.85, 29.25, 28.9, 29.33, 30.11, 29.67, 29.59], [5.4, 5.48, 5.46, 5.49, 5.39, 5.47, 5.46, 5.53, 5.5, 5.47, 5.39, 5.35, 5.37, 5.24, 5.26, 5.08, 4.57, 4.44, 4.5, 4.56, 4.52, 4.59, 4.66, 4.67, 4.66, 4.72, 4.84, 4.81, 4.84, 4.88, 4.89, 4.82, 4.74, 4.84, 4.79, 4.63], [3.71, 3.75, 3.73, 3.79, 3.72, 3.77, 3.76, 3.74, 3.78, 3.71, 3.61, 3.58, 3.61, 3.53, 3.5, 3.42, 3.08, 2.95, 3.04, 3.05, 3.05, 3.13, 3.12, 3.14, 3.11, 3.07, 3.23, 3.3, 3.31, 3.3, 3.33, 3.31, 3.22, 3.31, 3.25, 3.12], [5.72, 5.75, 5.74, 5.81, 5.69, 5.79, 5.77, 5.8, 5.89, 5.78, 5.7, 5.69, 5.75, 5.7, 5.71, 5.54, 4.99, 4.89, 4.94, 5.08, 5.39, 5.35, 5.23, 5.26, 5.19, 5.18, 5.31, 5.33, 5.31, 5.38, 5.39, 5.41, 5.28, 5.3, 5.38, 5.12], [7.62, 7.56, 7.68, 7.75, 7.79, 7.84, 7.82, 7.8, 7.92, 7.96, 7.93, 7.87, 7.86, 7.82, 7.9, 7.7, 6.93, 6.91, 7.18, 7.31, 7.35, 7.53, 7.47, 7.48, 7.35, 7.33, 7.46, 7.47, 7.39, 7.47, 7.48, 8.06, 8.02, 8.01, 8.11, 7.87], [3.7, 3.7, 3.68, 3.7, 3.63, 3.66, 3.63, 3.63, 3.66, 3.63, 3.6, 3.59, 3.63, 3.6, 3.61, 3.54, 3.19, 3.27, 3.27, 3.31, 3.3, 3.32, 3.33, 3.38, 3.36, 3.34, 3.39, 3.39, 3.37, 3.42, 3.43, 3.37, 3.32, 3.36, 3.37, 3.3]]\n" + ] + } + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### 编码哈密顿量\n", + "\n", + "这里我们将式（2）中的二进制变量用式（3）替换，从而构建哈密顿量 $H_C$。\n", + "\n", + "在编码哈密顿量的过程中，首先需要计算各股票回报率之间的协方差矩阵 $S$。量桨平台的 finance 模块有支持计算该协方差矩阵的函数，用户可以直接调用。" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 4, + "source": [ + "s = data.get_asset_return_covariance_matrix()" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "第二个是需要计算出各个股票的平均投资回报率向量 $\\mu$。同样的，量桨也提供有计算各股票平均投资回报率的函数。" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 5, + "source": [ + "mu = data.get_asset_return_mean_vector()" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "下面根据设定和计算出来的参数来构建哈密顿量，这里我们设置惩罚参数为可投资的股票数量。" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 6, + "source": [ + "q = 0.5 # 风险系数\n", + "budget = num_assets // 2 # 资金预算\n", + "penalty = num_assets # 惩罚参数 \n", + "hamiltonian = portfolio_optimization_hamiltonian(penalty, mu, s, q, budget)\n" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### 计算损失函数\n", + "\n", + "我们使用 $U_3(\\vec{\\theta})$ 和 $\\text{CNOT}$ 门构造的参数化量子电路，通过调用量桨内置的 [`complex entangled layer`](https://qml.baidu.com/api/paddle_quantum.circuit.uansatz.html) 构造实现。该电路会返回一个输出态 $|\\vec{\\theta}\\rangle$，根据该参数便可以计算投资组合优化问题在经典-量子混合模型下损失的函数:\n", + "\n", + "$$\n", + "L(\\vec{\\theta}) = \\langle\\vec{\\theta}|H_C|\\vec{\\theta}\\rangle.\n", + "\\tag{4}\n", + "$$\n", + "\n", + "之后我们利用经典的优化算法寻找最优参数 $\\vec{\\theta}^*$。下面的代码给出了通过量桨和飞桨搭建网络的过程。" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 7, + "source": [ + "class PONet(paddle.nn.Layer):\n", + "\n", + " def __init__(self, n, p, dtype=\"float64\"):\n", + " super(PONet, self).__init__()\n", + "\n", + " self.p = p\n", + " self.num_qubits = n\n", + " self.theta = self.create_parameter(shape=[self.p, self.num_qubits, 3],\n", + " default_initializer=paddle.nn.initializer.Uniform(low=0, high=2 * np.pi),\n", + " dtype=dtype, is_bias=False)\n", + "\n", + " def forward(self, hamiltonian):\n", + " \"\"\"\n", + " 前向传播\n", + " \"\"\"\n", + " cir = UAnsatz(self.num_qubits)\n", + " cir.complex_entangled_layer(self.theta, self.p)\n", + " cir.run_state_vector()\n", + " loss = cir.expecval(hamiltonian)\n", + "\n", + " return loss, cir" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### 训练量子神经网络\n", + "\n", + "定义好了量子神经网络后，我们使用梯度下降的方法来更新其中的参数，使得式（4）的期望值最小。" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 8, + "source": [ + "SEED = 1000 # 随机数种子\n", + "p = 2 # 量子电路的层数\n", + "ITR = 600 # 迭代次数\n", + "LR = 0.4 # 梯度下降优化速率 " + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "使用飞桨，优化上面定义的网络。" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 9, + "source": [ + "# 比特数量\n", + "n = len(mu)\n", + "\n", + "# 固定随机数种子\n", + "paddle.seed(SEED)\n", + "\n", + "# 定义量子神经网络\n", + "net = PONet(n, p)\n", + "\n", + "# 使用 Adam 优化器\n", + "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters())\n", + "\n", + "# 梯度下降优循环\n", + "for itr in range(1, ITR + 1):\n", + " loss, cir = net(hamiltonian)\n", + " loss.backward()\n", + " opt.minimize(loss)\n", + " opt.clear_grad()\n", + " if itr % 50 == 0:\n", + " print(\"循环数:\", itr,\" 损失:\", \"%.7f\"% loss.numpy())\n", + " " + ], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "循环数: 50 损失: 0.0399075\n", + "循环数: 100 损失: 0.0098776\n", + "循环数: 150 损失: 0.0085535\n", + "循环数: 200 损失: 0.0074563\n", + "循环数: 250 损失: 0.0066519\n", + "循环数: 300 损失: 0.0061940\n", + "循环数: 350 损失: 0.0059859\n", + "循环数: 400 损失: 0.0059068\n", + "循环数: 450 损失: 0.0058807\n", + "循环数: 500 损失: 0.0058731\n", + "循环数: 550 损失: 0.0058712\n", + "循环数: 600 损失: 0.0058707\n" + ] + } + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### 理论最小损失值\n", + "\n", + "理论 $C_x$ 的最小值对应的是我们所构建的哈密顿量的最小特征值。所以我们希望参数化电路优化的损失函数的值接近理论最小值。对于小一点的 ``num_assets``，我们可以根据以下代码进行验证。" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 10, + "source": [ + "H_C_matrix = hamiltonian.construct_h_matrix()\n", + "print(\"理论最小损失值：\", np.linalg.eigvalsh(H_C_matrix)[0]) \n", + "print(\"实际最小损失值：\", float(loss.numpy()))" + ], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "理论最小损失值： 0.0058710575103759766\n", + "实际最小损失值： 0.005870710695958458\n" + ] + } + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "在这个例子中，上面参数化电路优化出来的的最小损失和理论最小损失是非常接近的，这代表着我们之后给出的投资方案是最优的。如果两个值不太吻合，可以通过改变随机种子 `SEED`，量子电路的层数 `p`，迭代次数 `ITR` 和梯度下降优化速率 `LR` 等参数重新计算。 " + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### 解码量子答案\n", + "\n", + "当调用优化器求得损失函数的最小值以及相对应的一组参数 $\\vec{\\theta}^*$后，为了进一步求得投资组合优化问题的近似解，需要从电路输出的量子态 $|\\vec{\\theta}^*\\rangle$ 中解码出经典优化问题的答案。物理上，解码量子态需要对量子态进行测量，然后统计测量结果的概率分布：\n", + "\n", + "$$\n", + "p(z) = |\\langle z|\\vec{\\theta}^*\\rangle|^2.\n", + "\\tag{5}\n", + "$$\n", + "\n", + "在量子参数化电路表达能力足够的情况下，某个比特串出现的概率越大，意味着其是投资组合优化问题最优解的可能性越大。\n", + "\n", + "量桨提供了查看参数化量子电路输出状态的测量结果概率分布的函数。\n" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 11, + "source": [ + "# 模拟重复测量电路输出态 2048 次\n", + "prob_measure = cir.measure(shots=2048)\n", + "investment = max(prob_measure, key=prob_measure.get)\n", + "print(\"利用哈密顿量找到的解的比特串形式：\",investment)" + ], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "利用哈密顿量找到的解的比特串形式： 0100110\n" + ] + } + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "我们的测量结果是表示投资组合优化问题答案的比特串：字符串中该位置为 $1$，表示该笔资产被选定投资。如上面的结果 `0100110` 就表示在可选的 $7$ 支可投资的项目中，选择了第二、第五、第六三支股票。同时，字符串中 $1$ 的数量应该和预算数相同。如果最后的情况不是这样，读者依然可以通过调整参数化量子电路的参数值或参数化量子电路的结构来获得更好的训练效果。" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### 结语\n", + "\n", + "本教程中，投资组合优化问题的最优解是在均值-方差组合优化方法基础上通过变分量子本征求解器（Variational Quantum Eigensolver, VQE）近似得到的。在给定投资预算和可投资项目信息以及投资风险的基础上，通过计算投资项目的回报率以及各投资项目回报率之间的协方差矩阵，应用参数化量子电路寻找最优的投资组合。" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "_______\n", + "\n", + "## 参考文献\n", + "\n", + "[1] Orus, Roman, Samuel Mugel, and Enrique Lizaso. \"Quantum computing for finance: Overview and prospects.\" [Reviews in Physics 4 (2019): 100028.](https://arxiv.org/abs/1807.03890)\n", + "\n", + "[2] Egger, Daniel J., et al. \"Quantum computing for Finance: state of the art and future prospects.\" [IEEE Transactions on Quantum Engineering (2020).](https://arxiv.org/abs/2006.14510)\n", + "\n", + "[3] Markowitz, H.M. (March 1952). \"Portfolio Selection\". [The Journal of Finance. 7 (1): 77–91. doi:10.2307/2975974. JSTOR 2975974.](https://www.jstor.org/stable/2975974)" + ], + "metadata": {} + } + ], + "metadata": { + "interpreter": { + "hash": "3b61f83e8397e1c9fcea57a3d9915794102e67724879b24295f8014f41a14d85" + }, + "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.7.10" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} \ No newline at end of file diff --git a/tutorial/combinatorial_optimization/PortfolioOptimization_EN.ipynb b/tutorial/combinatorial_optimization/PortfolioOptimization_EN.ipynb new file mode 100644 index 0000000..219e4a2 --- /dev/null +++ b/tutorial/combinatorial_optimization/PortfolioOptimization_EN.ipynb @@ -0,0 +1,511 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "source": [ + "# Quantum Finance Application on Portfolio Optimization\n", + "\n", + " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "## Overview\n", + "\n", + "Current finance problems can be mainly tackled by three areas of quantum algorithms: quantum simulation, quantum optimization, and quantum machine learning [1,2]. Many financial problems are essentially combinatorial optimization problems, and corresponding algorithms usually have high time complexity and are difficult to implement. Due to the power of quantum computing, these complex problems are expected to be solved by quantum algorithms in the future.\n", + "\n", + "The Quantum Finance module of Paddle Quantum focuses on quantum optimization: how to apply quantum algorithms in real finance optimization problems. This tutorial focuses on how to use quantum algorithms to solve the portfolio optimization problem." + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "## Portfolio Optimization Problem\n", + "\n", + "A portfolio is a collection of financial investments, such as stocks, bonds, cash, etc. Many investment managers face the portfolio optimization problem. This problem requires practitioners to invest various projects, according to their target returns and risks. This aims to minimize the risk given certain return or maximize the return given certain risk.\n", + "\n", + "Detailed description of portfolio optimization is as follows: If you are an active investment manager who wants to invest $K$ dollars to $N$ projects, each with its own return and risk, your goal is to find an optimal way to invest the projects, taking into account the market impact and transaction costs." + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### Encoding Portfolio Optimization Problem\n", + "\n", + "To transform the portfolio optimization problem into a problem applicable for parameterized quantum circuits, we need to encode portfolio optimization problem into a Hamiltonian. To make the modeling easy to formulate, two assumptions are made to constrain the problem：\n", + "* Each asset is invested with an equal amount of money.\n", + "* Budget is a multiple of each investment amount and must be fully spent.\n", + "\n", + "\n", + "In this model we unitize the investment amount, i.e., if the budget is $3$, then the manager should invest $3$ assets. Since the actual investment budget is limited and there are many investable assets, it is important to set the number of investable assets larger than the budget.\n", + "\n", + "In the theory of portfolio optimization, the overall risk of a portfolio is related to the covariance between assets, which is proportional to the correlation coefficients of any two assets. The smaller the correlation coefficients, the smaller the covariance, and then the smaller the overall risk of the portfolio [3].\n", + "\n", + "Here we use the mean-variance approach to model this problem:\n", + "\n", + "$$\n", + "\\omega = \\max _{x \\in\\{0,1\\}^{n}} \\mu^{T} x - q x^{T} S x \\quad\\quad \\tag{1}\n", + "\\text { subject to: } 1^{T} x=B,\n", + "$$\n", + "\n", + "where each symbol has the following meaning:\n", + "* $x\\in {\\{0,1\\}}^N$ denotes the vector of binary decision variables, which indicate which each assets is picked ($x_i=1$) or not ($x_i = 0$),\n", + "* $\\mu \\in \\mathbb{R}^n$ defines the expected returns for the assets,\n", + "* $S \\in \\mathbb{R}^{n \\times n}$ represents the covariances between the assets,\n", + "* $q > 0$ represents the risk factor of investment decision making,\n", + "* $\\mathbb{1}$ denotes a vector with all values of $1$,\n", + "* $B$ denotes the budget, i.e. the number of assets to be selected out of $N$.\n", + "\n", + "\n", + "According to the model equation, we can define the loss function:\n", + "\n", + "$$\n", + "C_x = q \\sum_i \\sum_j s_{ji}x_ix_j - \\sum_{i}x_i \\mu_i + A \\left(B - \\sum_i x_i\\right)^2, \\tag{2}\n", + "$$\n", + "\n", + "where $s_{ij}$ denotes the elements of the covariance matrix $S$.\n", + "\n", + "Since the loss function is to be optimized using the gradient descent method, some modifications are made in the definition based on the equations of the model. The first term represents the risk of the investment. The second term represents the expected return on this investment. The third term constrains the budget $B$ to be invested evenly in different projects. $A$ is the penalty parameter, usually set to a larger number. \n", + "\n", + "We now need to transform the cost function $C_x$ into a Hamiltonian to realize the encoding of the portfolio optimization problem. Each variable $x_{i}$ has two possible values, $0$ and $1$, corresponding to quantum states $|0\\rangle$ and $|1\\rangle$. Note that every variable corresponds to a qubit and so $n$ qubits are needed for solving the portfolio optimization problem. The Pauli $Z$ operator has two eigenstates, $|0\\rangle$ and $|1\\rangle$ . Their corresponding eigenvalues are 1 and -1, respectively. So we consider encoding the cost function as a Hamiltonian using the pauli $Z$ matrix.\n", + "\n", + "Now we would like to consider the mapping\n", + "$$\n", + "x_{i} \\mapsto \\frac{I-Z_{i}}{2}, \\tag{4}\n", + "$$\n", + "\n", + "where $Z_{i} = I \\otimes I \\otimes \\ldots \\otimes Z \\otimes \\ldots \\otimes I$ with $Z$ operates on the qubit at position $i$. Under this mapping, the value of $x_i$ can be illustrated in a different way. If the qubit $i$ is in state $|1\\rangle$, then $x_{i} |1\\rangle = \\frac{I-Z_{i}}{2} |1\\rangle = 1|1\\rangle $, which means that the stork $i$ is in the optimal portfolio. Also, for a qubit $i$ in state $|0\\rangle$, $x_{i}|0\\rangle = \\frac{I-Z_{i}}{2} |0\\rangle = 0 |0\\rangle $.\n", + "\n", + "Thus using the above mapping, we can transform the cost function $C_x$ into a Hamiltonian $H_C$ for the system of $n$ qubits and realize the quantumization of the portfolio optimization problem. Then the ground state of $H_C$ is the optimal solution to the portfolio optimization problem. In the following section, we will show how to use a parameterized quantum circuit to find the ground state, i.e., the eigenvector with the smallest eigenvalue." + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "## Paddle Quantum Implementation\n", + "\n", + "To investigate the portfolio optimization problem using Paddle Quantum, there are some required packages to import, which are shown below. " + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 1, + "source": [ + "# Import packages needed\n", + "import numpy as np\n", + "import pandas as pd\n", + "import datetime\n", + "\n", + "# Import related modules from Paddle Quantum and PaddlePaddle\n", + "import paddle\n", + "from paddle_quantum.circuit import UAnsatz\n", + "from paddle_quantum.utils import pauli_str_to_matrix\n", + "from paddle_quantum.finance import DataSimulator, portfolio_optimization_hamiltonian" + ], + "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:00:15.901429Z", + "start_time": "2021-05-17T08:00:12.708945Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "### Prepare experimental data\n", + "\n", + "In this tutorial, we choose stocks as the investment asset. For the data used in the experimental tests, two options are provided:\n", + "* The first method is to generate random data according to certain requirements, e.g. number of assets.\n", + "\n", + "If the user prepares data using this method, then when initializing the data, it is necessary to give the list of parameters: a list of names of investable stocks (assets), the start date and end date of the trading data." + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 2, + "source": [ + "num_assets = 7 # Number of investable projects\n", + "stocks = [(\"STOCK%s\" % i) for i in range(num_assets)] \n", + "data = DataSimulator( stocks = stocks, start = datetime.datetime(2016, 1, 1),\n", + " end = datetime.datetime(2016, 1, 30))" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "* The second method is that the user can choose to set the data themselves, i.e. real stock data collected by themselves. Considering that the number of stocks contained in the file may be large, the user can specify the number of stocks used for this experiment, i.e. `num_assets` as initialized above.\n", + "\n", + "We collect the closing prices of 12 stocks for 35 trading days into the `realStockData_12.csv` file, where we choose to read only the first 3 stocks.\n", + "\n", + "In this tutorial, we choose to read real data as experimental data." + ], + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:00:16.212260Z", + "start_time": "2021-05-17T08:00:15.918792Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 3, + "source": [ + "df = pd.read_csv('realStockData_12.csv')\n", + "dt = []\n", + "for i in range(num_assets): \n", + " mylist = df['closePrice'+str(i)].tolist()\n", + " dt.append(mylist) \n", + "# Output the closing price of the seven stocks read from the file for the 35 trading days\n", + "print(dt) \n", + "# Specify the experimental data as a local file read by the user\n", + "data.set_data(dt) " + ], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "[[16.87, 17.18, 17.07, 17.15, 16.66, 16.79, 16.69, 16.99, 16.76, 16.52, 16.33, 16.39, 16.45, 16.0, 16.09, 15.54, 13.99, 14.6, 14.63, 14.77, 14.62, 14.5, 14.79, 14.77, 14.65, 15.03, 15.37, 15.2, 15.24, 15.59, 15.58, 15.23, 15.04, 14.99, 15.11, 14.5], [32.56, 32.05, 31.51, 31.76, 31.68, 32.2, 31.46, 31.68, 31.39, 30.49, 30.53, 30.46, 29.87, 29.21, 30.11, 28.98, 26.63, 27.62, 27.64, 27.9, 27.5, 28.67, 29.08, 29.08, 29.95, 30.8, 30.42, 29.7, 29.65, 29.85, 29.25, 28.9, 29.33, 30.11, 29.67, 29.59], [5.4, 5.48, 5.46, 5.49, 5.39, 5.47, 5.46, 5.53, 5.5, 5.47, 5.39, 5.35, 5.37, 5.24, 5.26, 5.08, 4.57, 4.44, 4.5, 4.56, 4.52, 4.59, 4.66, 4.67, 4.66, 4.72, 4.84, 4.81, 4.84, 4.88, 4.89, 4.82, 4.74, 4.84, 4.79, 4.63], [3.71, 3.75, 3.73, 3.79, 3.72, 3.77, 3.76, 3.74, 3.78, 3.71, 3.61, 3.58, 3.61, 3.53, 3.5, 3.42, 3.08, 2.95, 3.04, 3.05, 3.05, 3.13, 3.12, 3.14, 3.11, 3.07, 3.23, 3.3, 3.31, 3.3, 3.33, 3.31, 3.22, 3.31, 3.25, 3.12], [5.72, 5.75, 5.74, 5.81, 5.69, 5.79, 5.77, 5.8, 5.89, 5.78, 5.7, 5.69, 5.75, 5.7, 5.71, 5.54, 4.99, 4.89, 4.94, 5.08, 5.39, 5.35, 5.23, 5.26, 5.19, 5.18, 5.31, 5.33, 5.31, 5.38, 5.39, 5.41, 5.28, 5.3, 5.38, 5.12], [7.62, 7.56, 7.68, 7.75, 7.79, 7.84, 7.82, 7.8, 7.92, 7.96, 7.93, 7.87, 7.86, 7.82, 7.9, 7.7, 6.93, 6.91, 7.18, 7.31, 7.35, 7.53, 7.47, 7.48, 7.35, 7.33, 7.46, 7.47, 7.39, 7.47, 7.48, 8.06, 8.02, 8.01, 8.11, 7.87], [3.7, 3.7, 3.68, 3.7, 3.63, 3.66, 3.63, 3.63, 3.66, 3.63, 3.6, 3.59, 3.63, 3.6, 3.61, 3.54, 3.19, 3.27, 3.27, 3.31, 3.3, 3.32, 3.33, 3.38, 3.36, 3.34, 3.39, 3.39, 3.37, 3.42, 3.43, 3.37, 3.32, 3.36, 3.37, 3.3]]\n" + ] + } + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### Encoding Hamiltonian\n", + "\n", + "Here we construct the Hamiltonian $H_C$ of Eq. (2) with the replacement in Eq. (3). \n", + "\n", + "In the process of encoding Hamiltonian, we first need to calculate the covariance matrix $S$ between the returns of each stock, which is available in the ``finance`` module and can be called directly." + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 4, + "source": [ + "s = data.get_asset_return_covariance_matrix()" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "The second step is to compute the expected return vector $\\mu$ for each stock. Similarly, paddle quantum also support this function to users." + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 5, + "source": [ + "mu = data.get_asset_return_mean_vector()" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "Based on the provided and calculated parameters, the Hamiltonian is constructed below. Here we set the penalty parameter to the number of investable stocks." + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 6, + "source": [ + "q = 0.5 # risk appetite of the decision maker\n", + "budget = num_assets // 2 # budget\n", + "penalty = num_assets # penalty parameter \n", + "hamiltonian = portfolio_optimization_hamiltonian(penalty, mu, s, q, budget)" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### Calculating the loss function \n", + "\n", + "We adopt a parameterized quantum circuit consisting of $U_3(\\vec{\\theta})$ and $\\text{CNOT}$ gates. It can be constructed by calling the built-in function [`complex entangled layer`](https://qml.baidu.com/api/paddle_quantum.circuit.uansatz.html).\n", + "\n", + "After running the quantum circuit, we obtain the circuit output $|\\vec{\\theta\n", + "}\\rangle$. From the output state of the circuit, we can calculate the loss function of the portfolio optimization under the classical-quantum hybrid model:\n", + "\n", + "$$\n", + "L(\\vec{\\theta}) = \\langle\\vec{\\theta}|H_C|\\vec{\\theta}\\rangle.\n", + "\\tag{4}\n", + "$$\n", + "\n", + "We then use a classical optimization algorithm to minimize this function and find the optimal parameters $\\vec{\\theta}^*$. The following code shows a complete network built with Paddle Quantum and PaddlePaddle." + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 7, + "source": [ + "class PONet(paddle.nn.Layer):\n", + "\n", + " def __init__(self, n, p, dtype=\"float64\"):\n", + " super(PONet, self).__init__()\n", + "\n", + " self.p = p\n", + " self.num_qubits = n\n", + " self.theta = self.create_parameter(shape=[self.p, self.num_qubits, 3],\n", + " default_initializer=paddle.nn.initializer.Uniform(low=0, high=2 * np.pi),\n", + " dtype=dtype, is_bias=False)\n", + "\n", + " def forward(self, hamiltonian):\n", + " \"\"\"\n", + " Forward propagation\n", + " \"\"\"\n", + " # Define a circuit with complex entangled layers\n", + " cir = UAnsatz(self.num_qubits)\n", + " cir.complex_entangled_layer(self.theta, self.p)\n", + " # Run the quantum circuit\n", + " cir.run_state_vector()\n", + " # Calculate the loss function\n", + " loss = cir.expecval(hamiltonian)\n", + "\n", + " return loss, cir" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### Training the quantum neural network\n", + "\n", + "After defining the quantum neural network, we use the gradient descent method to update the parameters to minimize the expectation value in Eq. (4). " + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 8, + "source": [ + "SEED = 1000 # Set a global RNG seed \n", + "p = 2 # Number of layers in the quantum circuit\n", + "ITR = 600 # Number of training iterations\n", + "LR = 0.4 # Learning rate of the optimization method based on gradient descent" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "Here, we optimize the network defined above in PaddlePaddle." + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 11, + "source": [ + "# number of qubits\n", + "n = len(mu)\n", + "\n", + "# Fix paddle random seed\n", + "paddle.seed(SEED)\n", + "\n", + "# Building Quantum Neural Networks\n", + "net = PONet(n, p)\n", + "\n", + "# Use Adam optimizer\n", + "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters())\n", + "\n", + "# Gradient descent iteration\n", + "for itr in range(1, ITR + 1):\n", + " # Run the network defined above\n", + " loss, cir = net(hamiltonian)\n", + " # Calculate the gradient and optimize\n", + " loss.backward()\n", + " opt.minimize(loss)\n", + " opt.clear_grad()\n", + " if itr % 50 == 0:\n", + " print(\"iter: \", itr, \" loss: \", \"%.7f\"% loss.numpy())\n", + " " + ], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "iter: 50 loss: 0.0399075\n", + "iter: 100 loss: 0.0098776\n", + "iter: 150 loss: 0.0085535\n", + "iter: 200 loss: 0.0074563\n", + "iter: 250 loss: 0.0066519\n", + "iter: 300 loss: 0.0061940\n", + "iter: 350 loss: 0.0059859\n", + "iter: 400 loss: 0.0059068\n", + "iter: 450 loss: 0.0058807\n", + "iter: 500 loss: 0.0058731\n", + "iter: 550 loss: 0.0058712\n", + "iter: 600 loss: 0.0058707\n" + ] + } + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### Theoretical minimum loss value\n", + "\n", + "The theoretical minimum value of $C_x$ corresponds to the minimum eigenvalue of the Hamiltonian constructed above. So we would like to see the value of the loss function found by the parameterized circuit optimization close to the theoretical minimum. For smaller ``num_assets``, we can verify this based on the following code." + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 12, + "source": [ + "H_C_matrix = hamiltonian.construct_h_matrix()\n", + "print(\"Theoretical minimum loss value: \", np.linalg.eigvalsh(H_C_matrix)[0])\n", + "print(\"Practical minimum loss value: \", float(loss.numpy()))" + ], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Theoretical minimum loss value: 0.0058710575103759766\n", + "Practical minimum loss value: 0.005870710695958458\n" + ] + } + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "In this case, the minimum loss from the parameterized circuit optimization is the same as the theoretical minimum loss, which ensures that the investment solution found is optimal. If two values do not match well, we can adjust parameters such as the random seed ``SEED``, the number of layers of the quantum circuit ``p``, the number of iterations ``ITR`` and the gradient descent optimization rate ``LR``, to reapproximate the optimal solution." + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### Decoding the quantum solution\n", + "\n", + "After obtaining the minimum value of the loss function and the corresponding set of parameters $\\vec{\\theta}^*$, our task has not been completed. In order to obtain an approximate solution to the portfolio optimization problem, it is necessary to decode the solution to the classical optimization problem from the quantum state $|\\vec{\\theta}^*\\rangle$ output by the circuit. Physically, to decode a quantum state, we need to measure it and then calculate the probability distribution of the measurement results:\n", + "\n", + "$$\n", + "p(z) = |\\langle z|\\vec{\\theta}^*\\rangle|^2.\n", + "\\tag{5}\n", + "$$\n", + "\n", + "In the case of quantum parameterized circuits with sufficient expressiveness, the greater the probability of a certain bit string, the greater the probability that it corresponds to an optimal solution of the portfolio optimization problem.\n", + "\n", + "Paddle Quantum provides a function to read the probability distribution of the measurement results of the state output by the quantum circuit:" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "# Repeat the simulated measurement of the circuit output state 1024 times\n", + "prob_measure = cir.measure(shots=2048)\n", + "investment = max(prob_measure, key=prob_measure.get)\n", + "print(\"The bit string form of the solution: \",investment)" + ], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "The bit string form of the solution: 0100110\n" + ] + } + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "The result of our measurement is a bit string that represents the solution to the portfolio optimization problem: $1$ appearing at the $i$th bit indicates that the $i$th asset was selected for investment. For example, the result `0100110` above would indicate that the second, fifth and sixth stocks were selected out of the seven available investments. The number of $1$s in the string should be the same as the budget $B$. If the result is not like this, users can also get better training results by adjusting the parameters or structure of parameterized quantum circuits." + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### Conclusion\n", + "\n", + "In this tutorial, the optimal solution to the portfolio optimization is approximated through the Variational Quantum Eigensolver (VQE) based on the mean-variance approach. Given the budget, available assets and investment risks, the parameterized quantum circuits is applied to find the optimal portfolio by calculating the returns of investment projects and the covariance matrix between the returns of each investment project. " + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "_______\n", + "\n", + "## References\n", + "\n", + "[1] Orus, Roman, Samuel Mugel, and Enrique Lizaso. \"Quantum computing for finance: Overview and prospects.\" [Reviews in Physics 4 (2019): 100028.](https://arxiv.org/abs/1807.03890)\n", + "\n", + "[2] Egger, Daniel J., et al. \"Quantum computing for Finance: state of the art and future prospects.\" [IEEE Transactions on Quantum Engineering (2020).](https://arxiv.org/abs/2006.14510)\n", + "\n", + "[3] Markowitz, H.M. (March 1952). \"Portfolio Selection\". [The Journal of Finance. 7 (1): 77–91. doi:10.2307/2975974. JSTOR 2975974.](https://www.jstor.org/stable/2975974)" + ], + "metadata": {} + } + ], + "metadata": { + "interpreter": { + "hash": "3b61f83e8397e1c9fcea57a3d9915794102e67724879b24295f8014f41a14d85" + }, + "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.7.10" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} \ No newline at end of file diff --git a/tutorial/combinatorial_optimization/TSP_CN.ipynb b/tutorial/combinatorial_optimization/TSP_CN.ipynb index 70f0d9a..8bffa04 100644 --- a/tutorial/combinatorial_optimization/TSP_CN.ipynb +++ b/tutorial/combinatorial_optimization/TSP_CN.ipynb @@ -17,7 +17,7 @@ "\n", "旅行商问题（travelling salesman problem, TSP）是组合优化中最经典的 NP–困难的问题之一，它指的是以下这个问题：\"已知一系列的城市和它们之间的距离，这个旅行商想造访所有城市各一次，并最后返回出发地，求他的最短路线规划。\"\n", "\n", - "这个问题也可以用图论的语言来描述。已知一个有权重的完全图 $G = (V,E)$。它的每个顶点 $i \\in V$ 都对应一个城市 $i$，并且每一条边 $(i,j) \\in E$ 的权重 $w_{i,j}$ 对应城市 $i$ 和城市 $j$ 的距离。需要注意的是，$G$ 是个无向图，所以权重是对称的，即 $w_{i,j}= w_{j,i}$。根据以上定义，旅行商问题可以转化为找这个图中最短的哈密顿回路（Hamiltonian cycle）的问题。哈密顿回路为一个通过且仅通过每一个顶点一次的回路。" + "这个问题也可以用图论的语言来描述。已知一个有权重的完全图 $G = (V,E)$。它的每个顶点 $i \\in V$ 都对应一个城市 $i$，并且每一条边 $(i,j) \\in E$ 的权重 $w_{i,j}$ 对应城市 $i$ 和城市 $j$ 的距离。需要注意的是，$G$ 是个无向图，所以权重是对称的，即 $w_{i,j}= w_{j,i}$。根据以上定义，旅行商问题可以转化为找这个图中最短的哈密顿回路（Hamiltonian cycle）的问题。哈密顿回路为一个通过且仅通过每一个顶点一次的回路。 " ] }, { @@ -68,7 +68,7 @@ "x_{i,t} \\mapsto \\frac{I-Z_{i,t}}{2}, \\tag{5}\n", "$$\n", "\n", - "这里 $Z_{i,t} = I \\otimes I \\otimes \\ldots \\otimes Z \\otimes \\ldots \\otimes I$，也就是说 $Z$ 作用在位置在 $(i,t)$ 的量子比特上。通过这个映射，如果一个编号为 $(i,t)$ 的量子比特的量子态为 $|1\\rangle$，那么对应的二进制变量的取值为 $x_{i,t} = \\frac{I-Z_{i,t}}{2} |1\\rangle = 1$，也就是说顶点 $i$ 在最短哈密顿回路中的位置是 $t$。同样地，对于量子态为 $|0\\rangle$的量子比特 $(i,t)$，它所对应的二进制变量的取值为 $x_{i,t} = \\frac{I-Z_{i,t}}{2} |1\\rangle = 0$。\n", + "这里 $Z_{i,t} = I \\otimes I \\otimes \\ldots \\otimes Z \\otimes \\ldots \\otimes I$，也就是说 $Z$ 作用在位置在 $(i,t)$ 的量子比特上。通过这个映射，如果一个编号为 $(i,t)$ 的量子比特的量子态为 $|1\\rangle$，那么对应的二进制变量的取值为 $x_{i,t} |1\\rangle = \\frac{I-Z_{i,t}}{2} |1\\rangle = 1 |1\\rangle$，也就是说顶点 $i$ 在最短哈密顿回路中的位置是 $t$。同样地，对于量子态为 $|0\\rangle$的量子比特 $(i,t)$，它所对应的二进制变量的取值为 $x_{i,t} |0\\rangle = \\frac{I-Z_{i,t}}{2} |0\\rangle = 0 |0\\rangle$。\n", "\n", "我们用上述映射将 $C(x)$ 转化成量子比特数为 $n^2$ 的系统的哈密顿矩阵 $H_C$，从而实现了旅行商问题的量子化。这个哈密顿矩阵 $H_C$ 的基态即为旅行商问题的最优解。在接下来的章节中，我们将展示怎么用参数化量子电路找到这个矩阵的基态，即对应最小本征值的本征态。" ] @@ -529,7 +529,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.10" + "version": "3.8.8" }, "toc": { "base_numbering": 1, diff --git a/tutorial/combinatorial_optimization/TSP_EN.ipynb b/tutorial/combinatorial_optimization/TSP_EN.ipynb index 60c37cb..1ce3f7a 100644 --- a/tutorial/combinatorial_optimization/TSP_EN.ipynb +++ b/tutorial/combinatorial_optimization/TSP_EN.ipynb @@ -17,7 +17,7 @@ "\n", "One of the most famous NP-hard problems in combinatorial optimization, the travelling salesman problem (TSP) considers the following question: \"Given a list of cities and the distances between each pair of cities, what is the shortest possible route that visits each city exactly once and returns to the origin city?\" \n", "\n", - "This question can also be formulated in the language of graph theory. Given a weighted undirected complete graph $G = (V,E)$, where each vertex $i \\in V$ corresponds to city $i$ and the weight $w_{i,j}$ of each edge $(i,j,w_{i,j}) \\in E$ represents the distance between cities $i$ and $j$, the TSP is to find the shortest Hamiltonian cycle in $G$, where a Hamiltonian cycle is a closed loop on a graph in which every vertex is visited exactly once. Note that because $G$ is an undirected graph, weights are symmetric, i.e., $w_{i,j} = w_{j,i}$." + "This question can also be formulated in the language of graph theory. Given a weighted undirected complete graph $G = (V,E)$, where each vertex $i \\in V$ corresponds to city $i$ and the weight $w_{i,j}$ of each edge $(i,j,w_{i,j}) \\in E$ represents the distance between cities $i$ and $j$, the TSP is to find the shortest Hamiltonian cycle in $G$, where a Hamiltonian cycle is a closed loop on a graph in which every vertex is visited exactly once. Note that because $G$ is an undirected graph, weights are symmetric, i.e., $w_{i,j} = w_{j,i}$. " ] }, { @@ -68,7 +68,7 @@ "x_{i,t} \\mapsto \\frac{I-Z_{i,t}}{2}, \\tag{5}\n", "$$\n", "\n", - "where $Z_{i,t} = I \\otimes I \\otimes \\ldots \\otimes Z \\otimes \\ldots \\otimes I$ with $Z$ operates on the qubit at position $(i,t)$. Under this mapping, if a qubit $(i,t)$ is in state $|1\\rangle$, then $x_{i,t} = \\frac{I-Z_{i,t}}{2} |1\\rangle = 1$, which means vertex $i$ is visited at time $t$. Also, for a qubit $(i,t)$ in state $|0\\rangle$, $x_{i,t} = \\frac{I-Z_{i,t}}{2} |1\\rangle = 0$.\n", + "where $Z_{i,t} = I \\otimes I \\otimes \\ldots \\otimes Z \\otimes \\ldots \\otimes I$ with $Z$ operates on the qubit at position $(i,t)$. Under this mapping, if a qubit $(i,t)$ is in state $|1\\rangle$, then $x_{i,t}|1\\rangle = \\frac{I-Z_{i,t}}{2} |1\\rangle = 1 |1\\rangle$, which means vertex $i$ is visited at time $t$. Also, for a qubit $(i,t)$ in state $|0\\rangle$, $x_{i,t} |0\\rangle= \\frac{I-Z_{i,t}}{2} |0\\rangle = 0|0\\rangle$.\n", "\n", "Thus using the above mapping, we can transform the cost function $C(x)$ into a Hamiltonian $H_C$ for the system of $n^2$ qubits and realize the quantumization of the TSP. Then the ground state of $H_C$ is the optimal solution to the TSP. In the following section, we will show how to use a parametrized quantum circuit to find the ground state, i.e., the eigenvector with the smallest eigenvalue.\n", "\n" @@ -530,7 +530,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.10" + "version": "3.8.8" }, "toc": { "base_numbering": 1, diff --git a/tutorial/combinatorial_optimization/realStockData_12.csv b/tutorial/combinatorial_optimization/realStockData_12.csv new file mode 100644 index 0000000..75359e7 --- /dev/null +++ b/tutorial/combinatorial_optimization/realStockData_12.csv @@ -0,0 +1,37 @@ +closePrice0,closePrice1,closePrice2,closePrice3,closePrice4,closePrice5,closePrice6,closePrice7,closePrice8,closePrice9,closePrice10,closePrice11 +16.87,32.56,5.4,3.71,5.72,7.62,3.7,6.94,5.43,3.46,8.22,4.56 +17.18,32.05,5.48,3.75,5.75,7.56,3.7,6.89,5.37,3.45,8.14,4.54 +17.07,31.51,5.46,3.73,5.74,7.68,3.68,6.91,5.37,3.41,8.1,4.55 +17.15,31.76,5.49,3.79,5.81,7.75,3.7,6.97,5.42,3.5,8.16,4.58 +16.66,31.68,5.39,3.72,5.69,7.79,3.63,6.85,5.29,3.42,7.93,4.48 +16.79,32.2,5.47,3.77,5.79,7.84,3.66,6.94,5.41,3.46,8.02,4.56 +16.69,31.46,5.46,3.76,5.77,7.82,3.63,7.01,5.42,3.48,8,4.53 +16.99,31.68,5.53,3.74,5.8,7.8,3.63,7.03,5.39,3.47,8.03,4.53 +16.76,31.39,5.5,3.78,5.89,7.92,3.66,7.04,5.45,3.48,8.05,4.56 +16.52,30.49,5.47,3.71,5.78,7.96,3.63,7.01,5.43,3.45,7.95,4.47 +16.33,30.53,5.39,3.61,5.7,7.93,3.6,6.99,5.35,3.4,7.92,4.42 +16.39,30.46,5.35,3.58,5.69,7.87,3.59,6.95,5.26,3.41,7.93,4.38 +16.45,29.87,5.37,3.61,5.75,7.86,3.63,6.96,5.54,3.42,7.99,4.35 +16,29.21,5.24,3.53,5.7,7.82,3.6,6.87,6.09,3.32,7.9,4.32 +16.09,30.11,5.26,3.5,5.71,7.9,3.61,6.87,6.7,3.33,8.01,4.34 +15.54,28.98,5.08,3.42,5.54,7.7,3.54,6.58,7.37,3.23,7.73,4.13 +13.99,26.63,4.57,3.08,4.99,6.93,3.19,5.92,8.11,2.91,6.96,3.72 +14.6,27.62,4.44,2.95,4.89,6.91,3.27,5.78,8.1,2.96,7.01,3.51 +14.63,27.64,4.5,3.04,4.94,7.18,3.27,5.89,8.91,3.02,7.06,3.61 +14.77,27.9,4.56,3.05,5.08,7.31,3.31,5.94,9.8,3.06,7.08,3.88 +14.62,27.5,4.52,3.05,5.39,7.35,3.3,5.93,10.78,3.05,7.07,3.87 +14.5,28.67,4.59,3.13,5.35,7.53,3.32,6.06,11.86,3.13,7.15,3.9 +14.79,29.08,4.66,3.12,5.23,7.47,3.33,6.16,10.67,3.15,7.17,3.91 +14.77,29.08,4.67,3.14,5.26,7.48,3.38,6.18,11.36,3.17,7.21,3.95 +14.65,29.95,4.66,3.11,5.19,7.35,3.36,6.15,10.56,3.14,7.19,3.94 +15.03,30.8,4.72,3.07,5.18,7.33,3.34,6.11,9.56,3.15,7.29,3.96 +15.37,30.42,4.84,3.23,5.31,7.46,3.39,6.35,9.15,3.18,7.41,4.04 +15.2,29.7,4.81,3.3,5.33,7.47,3.39,6.34,9.11,3.17,7.4,4.06 +15.24,29.65,4.84,3.31,5.31,7.39,3.37,6.26,8.89,3.12,7.34,3.99 +15.59,29.85,4.88,3.3,5.38,7.47,3.42,6.44,8.36,3.15,7.42,4.04 +15.58,29.25,4.89,3.33,5.39,7.48,3.43,6.46,8.68,3.16,7.52,4.03 +15.23,28.9,4.82,3.31,5.41,8.06,3.37,6.41,8.77,3.12,7.41,3.97 +15.04,29.33,4.74,3.22,5.28,8.02,3.32,6.32,9.65,3.06,7.31,3.9 +14.99,30.11,4.84,3.31,5.3,8.01,3.36,6.32,9.11,3.13,7.51,3.9 +15.11,29.67,4.79,3.25,5.38,8.11,3.37,6.42,8.41,3.15,7.5,3.88 +14.5,29.59,4.63,3.12,5.12,7.87,3.3,6.15,8.4,3.08,7.18,3.76 \ No newline at end of file diff --git a/tutorial/machine_learning/QClassifier_CN.ipynb b/tutorial/machine_learning/QClassifier_CN.ipynb index b6f968f..c8dce64 100644 --- a/tutorial/machine_learning/QClassifier_CN.ipynb +++ b/tutorial/machine_learning/QClassifier_CN.ipynb @@ -78,8 +78,6 @@ "import paddle\n", "from numpy import pi as PI\n", "from matplotlib import pyplot as plt\n", - "import warnings\n", - "warnings.filterwarnings(\"ignore\")\n", "\n", "from paddle import matmul, transpose\n", "from paddle_quantum.circuit import UAnsatz\n", @@ -215,7 +213,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -234,7 +232,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -643,7 +641,7 @@ "# 生成只作用在第一个量子比特上的泡利 Z 算符\n", "# 其余量子比特上都作用单位矩阵\n", "def Observable(n):\n", - " \"\"\"\n", + " r\"\"\"\n", " :param n: 量子比特数量\n", " :return: 局部可观测量: Z \\otimes I \\otimes ...\\otimes I\n", " \"\"\"\n", @@ -839,7 +837,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "以上都是我们定义的函数，下面我么讲运行主程序。" + "以上都是我们定义的函数，下面我们将运行主程序。" ] }, { @@ -876,19 +874,19 @@ "epoch: 3 iter: 100 loss: 0.0671 train acc: 1.0000 test acc: 1.0000\n", "epoch: 3 iter: 150 loss: 0.0849 train acc: 1.0000 test acc: 1.0000\n", "训练后的电路：\n", - "--Rz(0.542)----Ry(3.456)----Rz(2.699)----*--------------X----Ry(6.153)--\n", + "--Rz(0.542)----Ry(3.456)----Rz(2.699)----*--------------x----Ry(6.153)--\n", " | | \n", - "--Rz(3.514)----Ry(1.543)----Rz(2.499)----X----*---------|----Ry(3.050)--\n", + "--Rz(3.514)----Ry(1.543)----Rz(2.499)----x----*---------|----Ry(3.050)--\n", " | | \n", - "--Rz(5.947)----Ry(3.161)----Rz(3.897)---------X----*----|----Ry(1.583)--\n", + "--Rz(5.947)----Ry(3.161)----Rz(3.897)---------x----*----|----Ry(1.583)--\n", " | | \n", - "--Rz(0.718)----Ry(5.038)----Rz(1.348)--------------X----*----Ry(0.030)--\n", + "--Rz(0.718)----Ry(5.038)----Rz(1.348)--------------x----*----Ry(0.030)--\n", " \n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -902,7 +900,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "主程序段总共运行了 35.94043445587158 秒\n" + "主程序段总共运行了 23.798545360565186 秒\n" ] } ], diff --git a/tutorial/machine_learning/QClassifier_EN.ipynb b/tutorial/machine_learning/QClassifier_EN.ipynb index 4eba9d5..a82c369 100644 --- a/tutorial/machine_learning/QClassifier_EN.ipynb +++ b/tutorial/machine_learning/QClassifier_EN.ipynb @@ -65,8 +65,6 @@ "import paddle\n", "from numpy import pi as PI\n", "from matplotlib import pyplot as plt\n", - "import warnings\n", - "warnings.filterwarnings(\"ignore\")\n", "\n", "from paddle import matmul, transpose\n", "from paddle_quantum.circuit import UAnsatz\n", @@ -202,7 +200,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -221,7 +219,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -635,7 +633,7 @@ "# Generate Pauli Z operator that only acts on the first qubit\n", "# Act the identity matrix on rest of the qubits\n", "def Observable(n):\n", - " \"\"\"\n", + " r\"\"\"\n", " :param n: number of qubits\n", " :return: local observable: Z \\otimes I \\otimes ...\\otimes I\n", " \"\"\"\n", @@ -862,19 +860,19 @@ "epoch: 3 iter: 100 loss: 0.0671 train acc: 1.0000 test acc: 1.0000\n", "epoch: 3 iter: 150 loss: 0.0849 train acc: 1.0000 test acc: 1.0000\n", "The trained circuit:\n", - "--Rz(0.542)----Ry(3.456)----Rz(2.699)----*--------------X----Ry(6.153)--\n", + "--Rz(0.542)----Ry(3.456)----Rz(2.699)----*--------------x----Ry(6.153)--\n", " | | \n", - "--Rz(3.514)----Ry(1.543)----Rz(2.499)----X----*---------|----Ry(3.050)--\n", + "--Rz(3.514)----Ry(1.543)----Rz(2.499)----x----*---------|----Ry(3.050)--\n", " | | \n", - "--Rz(5.947)----Ry(3.161)----Rz(3.897)---------X----*----|----Ry(1.583)--\n", + "--Rz(5.947)----Ry(3.161)----Rz(3.897)---------x----*----|----Ry(1.583)--\n", " | | \n", - "--Rz(0.718)----Ry(5.038)----Rz(1.348)--------------X----*----Ry(0.030)--\n", + "--Rz(0.718)----Ry(5.038)----Rz(1.348)--------------x----*----Ry(0.030)--\n", " \n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -888,7 +886,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "The main program finished running in 35.49316954612732 seconds.\n" + "The main program finished running in 23.123697519302368 seconds.\n" ] } ], @@ -957,7 +955,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.3" + "version": "3.7.10" }, "toc": { "base_numbering": 1, diff --git a/tutorial/qnn_research/BarrenPlateaus_CN.ipynb b/tutorial/qnn_research/BarrenPlateaus_CN.ipynb index b36c1c7..09583a2 100644 --- a/tutorial/qnn_research/BarrenPlateaus_CN.ipynb +++ b/tutorial/qnn_research/BarrenPlateaus_CN.ipynb @@ -28,7 +28,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": { "ExecuteTime": { "end_time": "2021-03-02T12:20:39.463025Z", @@ -69,7 +69,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": { "ExecuteTime": { "end_time": "2021-03-02T12:20:39.972053Z", @@ -135,7 +135,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": { "ExecuteTime": { "end_time": "2021-03-02T12:20:52.236108Z", @@ -147,7 +147,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "主程序段总共运行了 4.645057678222656 秒\n", + "主程序段总共运行了 4.447464466094971 秒\n", "采样 300 个随机网络关于第一个参数梯度的均值是： 0.005925709445960606\n", "采样 300 个随机网络关于第一个参数梯度的方差是： 0.028249053148446363\n" ] @@ -252,7 +252,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": { "ExecuteTime": { "end_time": "2021-03-02T12:21:49.972769Z", @@ -262,7 +262,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -276,7 +276,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "主程序段总共运行了 1.504277229309082 秒\n" + "主程序段总共运行了 1.7720370292663574 秒\n" ] } ], @@ -379,7 +379,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": { "ExecuteTime": { "end_time": "2021-03-02T12:24:12.650054Z", @@ -391,7 +391,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "主程序段总共运行了 144.23979568481445 秒\n" + "主程序段总共运行了 96.94419932365417 秒\n" ] } ], @@ -480,7 +480,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "metadata": { "ExecuteTime": { "end_time": "2021-03-02T12:24:30.342035Z", @@ -497,7 +497,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -523,7 +523,7 @@ "plt.plot(n, means, \"o-.\")\n", "plt.xlabel(r\"Qubit #\")\n", "plt.ylabel(r\"$ \\partial \\theta_{i} \\langle 0|H |0\\rangle$ Mean\")\n", - "plt.title(\"Mean of {} sampled graident\".format(samples))\n", + "plt.title(\"Mean of {} sampled gradient\".format(samples))\n", "plt.xlim([1,9])\n", "plt.ylim([-0.06, 0.06])\n", "plt.grid()\n", @@ -540,7 +540,7 @@ "plt.semilogy(n, np.exp(n * slope + intercept), \"r--\", label=\"Slope {:03.4f}\".format(slope))\n", "plt.xlabel(r\"Qubit #\")\n", "plt.ylabel(r\"$ \\partial \\theta_{i} \\langle 0|H |0\\rangle$ Variance\")\n", - "plt.title(\"Variance of {} sampled graident\".format(samples))\n", + "plt.title(\"Variance of {} sampled gradient\".format(samples))\n", "plt.legend()\n", "plt.xlim([1,9])\n", "plt.ylim([0.0001, 0.1])\n", @@ -594,7 +594,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.0" + "version": "3.7.10" }, "toc": { "base_numbering": 1, diff --git a/tutorial/qnn_research/BarrenPlateaus_EN.ipynb b/tutorial/qnn_research/BarrenPlateaus_EN.ipynb index fea20c1..2067f71 100644 --- a/tutorial/qnn_research/BarrenPlateaus_EN.ipynb +++ b/tutorial/qnn_research/BarrenPlateaus_EN.ipynb @@ -26,7 +26,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": { "ExecuteTime": { "end_time": "2021-03-02T12:13:41.746113Z", @@ -67,7 +67,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": { "ExecuteTime": { "end_time": "2021-03-02T12:13:41.776722Z", @@ -134,7 +134,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": { "ExecuteTime": { "end_time": "2021-03-02T12:13:50.788968Z", @@ -146,7 +146,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "The main program segment has run in total 4.7065675258636475 seconds\n", + "The main program segment has run in total 5.674382448196411 seconds\n", "Use 300 samples to get the mean value of the gradient of the random network's first parameter, and we have： 0.005925709445960606\n", "Use 300 samples to get the variance of the gradient of the random network's first parameter, and we have： 0.028249053148446363\n" ] @@ -251,7 +251,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": { "ExecuteTime": { "end_time": "2021-03-02T12:14:18.147473Z", @@ -261,7 +261,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -275,7 +275,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "The main program segment has run in total 1.5652515888214111 seconds\n" + "The main program segment has run in total 1.9106006622314453 seconds\n" ] } ], @@ -378,7 +378,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": { "ExecuteTime": { "end_time": "2021-03-02T12:18:13.493641Z", @@ -390,7 +390,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "The main program segment has run in total 134.07549667358398 seconds\n" + "The main program segment has run in total 90.05470848083496 seconds\n" ] } ], @@ -481,7 +481,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "metadata": { "ExecuteTime": { "end_time": "2021-03-02T12:19:16.260635Z", @@ -498,7 +498,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAzEAAAEWCAYAAABWoBknAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdeXiU5fX/8ffJAgGSAArILioQ2Vf3DeRXRasFra274gJacevibhW3qtUubtWiKFoVtdYFlK/UqmitgoiiyCLigqCogCCERQg5vz/uJ2EIk2RCJpkM+byua67Ms86ZyeS5c557M3dHREREREQkXWSkOgAREREREZGqUBIjIiIiIiJpRUmMiIiIiIikFSUxIiIiIiKSVpTEiIiIiIhIWlESIyIiIiIiaUVJjOzQzOwAM/vEzArNbHiq40k1M/vCzP5fbR+7Ha91pZk9UBdiEZG6I7qW757qOBJhwUNmttLM3kl1PKlmZiPM7M3aPnY7X6/c71ltxyLlUxIjVRL987jRzFqUWT/LzNzMOqUmsnJdD9zt7rnu/lzZjWb2qJktNbPVZrbAzM4us32Imc03s3Vm9pqZ7RqzzczsVjNbET3+aGZWC+9ph+fuf3D3syvfs3rMbIyZPVrTryNSH5nZFDO7Ps76YWb2jZllVfWc0bX8s+REWOMOBH4CtHf3vctuNLPBZjbbzFZFZcizZtYuZntDM3swKp++MbPflDm+r5nNjMqnmWbWt+bfUv1QW9+z6P+mzjX9OjsqJTGyPT4HTixZMLNeQKPUhVOhXYE5FWy/Gejk7vnAz4AbzWwAQJSoPQP8HtgJeBd4MubYUcBwoA/QGzgKOCfZb2BHsz3/uIhIWhoPnBrn5s6pwGPuXpToidL0urEr8IW7ry1n+1zgcHdvBrQFPgHujdk+BugSnWcwcKmZDQUwswbA88CjQHPgYeD5aL1UIE2/SxKHkhjZHv8ATotZPh14JHaH6A7S7Wb2pZl9a2b3mVmjaFtzM3vBzJZF1ewvmFn7mGOnmtkNZvY/M1tjZv8uW/NT5rVGmtlCM/vezCaaWdto/afA7sCkqGq4Ydlj3X2Ou/9Yshg99oiWjwXmuPs/3X0DoUDpY2Z7xrzvP7n7Enf/CvgTMKKcGHOiWp8V0V23GWa2S7TtDDObF73Xz8zsnJjjBpnZEjO71My+i2qNhpvZkVHN0fdmdmXM/mPM7GkzezI633tm1qecmDLM7HIz+zSK6ykz2ylm+6lmtijadlV5n3+0785mNim6YzjDzG60mOr26G7TaDP7hFBQY2Z3mNni6JiZZnZQmffxaMxyubFU9D7MrFP02qdH38XlJcdH/wxcCRwffT8+qOg9ikiVPUe4ART7t92ccMPnETPb28zejq6JS83s7th/wsu5bpTeuTazn5rZ+9E1ZLGZjYk5tty//Wh7poVmq59G18qZZtYh2ranmb0cXV8/NrNflvcGzaxtVO58H5VDI6P1ZwEPAPtF15fryh7r7t+6+9cxqzYDsXflTwNucPeV7j4PuJ8tZcwgIAv4q7v/6O53AgYcWk6cR5rZ3Oi9fmVmvyv5fVjl5fGNZvZW9D4mRdf7x2Ku953K/M4utFCWLTez28ws7v+aFX3O0WtMjF7jHbaUy3GZ2WkxZcTvLabJsW0pFx81s9XAiAS/eyXfswpjqeR9jDeze8zsxeizn25me0Tb3oh2+yD6bI+v6D1KHO6uhx4JP4AvgP8HfAx0AzKBxYQ7RU6o1QD4KzCRUIDlAZOAm6NtOwM/BxpH2/4JPBfzGlOBT4GuhBqeqcAt5cRzKLAc6A80BO4C3igbbyXv6W/Auij+94DcaP0dwL1l9v0I+Hn0/Adgn5htA4E15bzGOdFn0Dj6zAYA+dG2nxIuigYcEsXSP9o2CCgCrgGygZHAMuDx6LPrAWwAdo/2HwNsAo6L9v8doeYsu+znAVwMTAPaR5/d34EJ0bbuQCFwcLTtz1EccT9L4Ino0Tg6djHwZsx2B16Ovg+NonWnRN+FLOC3wDdATsz7eDSRWCp5H52i176f8F3qA/wIdCv7OnrooUfyH9Hf3gMxy+cAs6LnA4B9o2tAJ2AecHHMvvGuGw50jp4PAnoRbsj2Br4FhkfbKvvbvwSYDRQQrr19outRk+j6dUYUV39CGdOjnPf3OqEMyQH6Eq7PQ6JtI2Kvg+Uc3xFYBRQTrt0jovXNo/h3idn3OGB29PzXwP+VOdcLwG/LeZ2lwEEx5y4pYxIpjxcSyqimhNqjBYT/A7IINzAfKvM7ey36nXWM9j277OdR2edMKE+eivbrCXxV3mfJljLiQKABcHv0WZaUEWOi5eHRd6URiX33OlcWSwLvYzzwPbB3tP0x4Il4r6PHdlxfUh2AHun1YEsSczWhKdZQQiGTFf0xdiIUCGuBPWKO2w/4vJxz9gVWxixPBa6OWT4PeKmcY8cBf4xZzo0uVp1i403gfWVGF8Cr2fIP/zjKJE/A/9hSyGwG9ozZ1iX6DCzO+c8E3gJ6JxDLc8BF0fNBwHogM1rOi14jNnmayZaCewwwLWZbBlsXXqWfR3TRHhKzb5vos8siJE2xF9omwMZ4n2X02W0CCmLW3ci2ScyhlbzvlUCfmPdRksRUGEsl76NT9NrtY7a/A5xQ9nX00EOP5D+i6+oPbElC/gf8upx9LwaejVne5rpBBf/0EW6e/SV6Xtnf/sfAsDjnOB74b5l1fweujbNvB0I5kBez7mZgfPR8BJUkMTHH7QRcBuwbc24nurETrfsJoXkahGbOT5Q5x2PAmHLO/yUhgcyvJI545fFVMct/IiZ5Ao4mSkpjfj9DY5bPA14p+3lU9DmzpUyJLV//UN5nGZURE2KWG5cpI8YQc3OzCt+9zpXFUtn3hZDExCbxRwLzE/k+61H5Q83JZHv9AziJcFF6pMy2loSLyMyoqnYV8FK0HjNrbGZ/j6p+VwNvAM3MLDPmHN/EPF9HSE7iaQssKllw90JgBdCunP3jcvfN7v4m4W7+r6LVhUB+mV3zgTXlbM8HCj26MpXxD2AK8ISZfW1hEIBsADM7wsymRVXRqwgXudjmcyvcfXP0fH3089uY7evZ+vNZHPO+ioElhM+prF2BZ2N+R/MIBfIu0f6x51lL+FzjaUlIGBbHrFscZ7+t1pnZby00o/shev2mbP2+S1QWS0Xvo0Si3ycRSaLouroMGGZhtKe9CDXJmFnXqPnSN1FZ8Ae2vQbEu5YQHb+PhQFXlpnZD8C5cY4v72+/A6HGv6xdgX1KrifRNeVkoHWcfdsC37v7mph1i6hi+QPg7t+zpV9LFqF8gW3LmPLKn7Lby/o5oWxZZGavm9l+kHB5XLa8qaj8ga1/Z4sov/wp73OOV6YsinOOEmXLiHVsW16VLX8S+e6RQCyJfF9U/tQQJTGyXdx9EaGZ0pGEzu+xlhMubD3cvVn0aOruJX+4vyVU4e/joUP9wdH67RnZ62vCRSScwKwJoXr8q+04F4SLVUl71zmEJgax596DLQMFbLU9eh53EAF33+Tu17l7d2B/Qpvw0yz00/kXofp7Fw8dPCezfZ9FiQ4xMWcQErOv4+y3GDgi5nfUzN1zPPTvWVrmPI0Jn2s8ywjNu9rHrOsQZ7/S5M5C/5fLgF8CzaP3/QPx33dlsVT0PioTL+EUkeR6hNC/41Tg3+5e8k/wvcB8oEtUFlzJtteAiv5GHyc0W+7g7k2B++IcX57FxO9nsRh4vcz1JNfdfxVn36+BncwsL2ZdR6pX/rQi1JasJFz7yitj5gC9zbYaNKE35ZdBM9x9WHT+5wjNoyC55XGJ2Ot/R8ovf8r7nEvKlLLnKc9SYsofC/1vy5ZXZb9HiXz3SCCWqnxfJMmUxEh1nEWo6t9q5JXo7v/9wF/MrBWAmbUzs8OjXfIISc4qCx2wr61GDI8DZ1gYarIh4W7KdHf/orIDzayVmZ1gZrkWOnkeThh17dVol2eBnmb2czPLIVRZf+ju86PtjwC/id5bW0JhML6c1xpsZr2iu1urCdXTmwntdxsSXSjN7AjgsO34HGINMLNjo7t5FxPagU+Ls999wE0WDRttZi3NbFi07WngKDM7MOrseD3lXC+iWqJngDHRXb092Xrgh3jyCAXDMiDLzK5h27uKJSqLpaL3UZlvgU5WTsdTEUmKRwjNkEcSahtK5BGuh4XRdaOq//jlEWpCNpjZ3oTWAYl6ALjBzLpY0NvMdib0K+lqYTCR7Oixl5l1K3sCd19MaCZ8s4XBW3oTysXHEgkguk4XWBicpCWhv9/7Ua0MhM/tagud7/ckfH7jo21TCWXIhRYG0jk/Wv8qZZhZAzM72cyauvsmwmdeUrufzPK4xCVRzB2Ai9h6VM8S5X7OccqU7oSBdMrzNHC0me0flRHXUXkSltB3L4FYEv6+lONbwgBEsh1UcMt2c/dP3f3dcjZfRugMOC2qqv0P4W4PhHbLjQg1NtMITc22N4ZXCG2D/0W4G7MHcEKihxMuXEsI/TFuJ3Tsez469zJCFfxN0fZ9ypz774TO+rMJHf5fjNbF05pwoV1NaO70OqEvxhrgQsJdsZWEQnhigvGX53lCO92VhDufx0YFV1l3RK/1bzNbQ/hd7ANh1DZgNCFJXBqda0kFr3k+oTnYN4SmcxMIyVN5pgD/R+j0uYgwOEHcZiMJxFLu+0jAP6OfK8zsvQSPEZEqiG4qvUXozxZ7ffsd4Zq3hnDjK94/uxU5D7g++ru/hi21C4n4c7T/vwnX5XGEfjtrCDeSTiDUIHwD3Eq42RTPiYT+N18Tbnxd6+4vJxhDO0L5t4ZQjhQDx8Rsv5bQ5G0Rocy4zd1fAnD3jYSO6qcRBgY4k9A3cmM5r3Uq8EVUHp9LGFgFklgex3ie0FdzFqFcHFd2hwQ+5/MJza6+ISRuD5X3YlEZcQGhA/5Swuf5HRWXQVX57pUby3Z8X8oaAzwcNUUrdxQ8ic/iN98XkXRkYYjRzu5+SmX71nActwKt3b2iu2ciIrIDMTMnNNFamMIYcgmJXRd3/zxVcUjNU02MiFSbhXHye0fNMvYmNKl4NtVxiYjIjs/Mjo6aezUhtKqYTRiNU3ZgdSqJMbOhFiYKWmhml8fZbmZ2Z7T9QzPrH7OtmYXJjOZbGPFov9qNXqReyyO0G15LaKLxJ0KTApG0ZWa7m9k4M3s61bGISIWGEZpzfU2Y7uCEckYKlR1InWlOFnV4XkAYB30JMAM40d3nxuxzJKHd45GENu93uPs+0baHCWN1PxB17Grs7qtq+W2IiEgdYGYPEkYB/M7de8asH0roR5VJmL/hlgTO9bS7H1djwYqISJVlpTqAGHsDC939MwAze4KQWc+N2WcY8EiUXU+Lal/aEO7+HkyYs6Skw1t5ndtERGTHNx64m5h5rKKbZfcQc7PMzCYSEpqbyxx/prt/VzuhiohIVdWlJKYdW49OtIRtRxiKt087tgzV+pCZ9SGMinFR2aF/AcxsFDAKICcnZ0DHjhUNPV43FBcXk5FRp1r+xZUucUL6xKo4ky9dYk2XOBcsWLDc3VumOo6y3P0NM+tUZnXcm2XufjOh1ma7qFypOekSJ6RPrIozudIlTkifWBMtV+pSEhNvTO+ybd3K2ycL6A9c4O7TzewO4HLC0Ltb7+w+FhgLUFBQ4B9//HG1gq4NU6dOZdCgQakOo1LpEiekT6yKM/nSJdZ0idPMKppJu65J5GZZqWjekJuAfmZ2RZTsbEPlSs1JlzghfWJVnMmVLnFC+sSaaLlSl5KYJWw9I2q8WcbL28eBJe4+PVr/NCGJERERKZHIzbItG9xXEObUEBGROqYu1SnNALqY2W5Rx/wT2HbSv4nAadEoZfsCP7j7Unf/BlhsZiWTKQ5h6740IiIiidwsExGRNFBnamLcvcjMzifM5J0JPOjuc8zs3Gj7fcBkwshkC4F1wBkxp7gAeCxKgD4rs01ERKT0ZhnwFeFm2UnJOLGZHQ0c3bZt22ScTkREKlFnkhgAd59MSFRi190X89yB0eUcOwsYWKMBiohIWjCzCcAgoIWZLQGudfdx8W6WJeP13H0SMKmgoGBkMs4nItW3adMmlixZwoYNG2rsNZo2bcq8efNq7PzJVNdizcnJoX379mRnZ2/X8XUqiREREUkGdz+xnPXb3CwTkR3TkiVLyMvLo1OnTpjF6xJXfWvWrCEvL69Gzp1sdSlWd2fFihUsWbKE3XbbbbvOUZf6xIiIiKQlMzvazMYWFhamOhQRiWzYsIGdd965xhIY2X5mxs4771ytWjIlMSIiItXk7pPcfVRubm6qQxGRGEpg6q7q/m6UxIiIiIiISFpREiMiIiIiUgNuuukmevToQe/evenbty/Tp4cpDQcNGsS7775ba3F8/vnnDB48mC5dunD88cezcePGbfZ57bXX6Nu3b+kjJyeH5557Dgh9WK666iq6du1Kt27duPPOO0uPmzp1Kn379qVHjx4ccsghW51z8+bN9OvXj6OOOirp70kd+0VEREREkuztt9/mhRde4L333qNhw4YsX748bvJQGy677DJGjx7NGWecwbnnnsu4ceP41a9+tdU+gwcPZtasWQB8//33dO7cmcMOOwyA8ePHs3jxYubPn09GRgbfffcdAKtWreK8887jpZdeomPHjqXrS9xxxx1069aN1atXJ/09qSZGRESkmtSxX0TKWrp0KS1atKBhw4YAtGjRgnhzSU2YMIFevXrRs2dPLrvsstL1ubm5/Pa3v6V///4MGTKEZcuWAfDpp58ydOhQBgwYwEEHHcT8+fMrjMPdefXVVxk+fDgAp59+emkNS3mefvppjjjiCBo3bgzAvffeyzXXXENGRkgdWrVqBcDjjz/OscceS8eOHbdaD2F0uBdffJGzzz67wtfaXkpiREREqkkd+0XSwKBB2z7+9rewbd26+NvHjw/bly/fdlslDjvsMBYvXkzXrl0577zzeP3117fZ5+uvv+ayyy7j1VdfZdasWcyYMaM0wVi7di39+/fnvffe45BDDuG6664DYNSoUdx1113MnDmT22+/nfPOO6/COFasWEGzZs3IygoNsNq3b89XX31V4TFPPPEEJ564ZaT6Tz/9lCeffJKBAwdyxBFH8MknnwCwYMECVq5cyaBBgxgwYACPPPJI6TEXX3wxf/zjH0sTn2RTEiMiIiIikmS5ubnMnDmTsWPH0rJlS44//njGlyRFkRkzZjBo0CBatmxJVlYWJ598Mm+88QYAGRkZHH/88QCccsopvPnmmxQWFvLWW2/xi1/8gr59+3LOOeewdOnSCuMIc8VvraKRwZYuXcrs2bM5/PDDS9f9+OOP5OTk8O677zJy5EjOPPNMAIqKipg5cyYvvvgiU6ZM4YYbbmDBggW88MILtGrVigEDBiT0WW0P9YkRERERkR3f1Knlb2vcuOLtLVpUvL0cmZmZDBo0iEGDBtGrVy8efvhhRowYUbo9XoJRHjOjuLiYZs2alfZdKc/hhx/Ot99+y8CBA7n//vtZtWoVRUVFQGjmFa9ZW4mnnnqKY445huzs7NJ17du35+c//zkAxxxzDGeccUbp+hYtWtCkSROaNGnCwQcfzAcffMB7773HxIkTmTx5Mhs2bGD16tWccsopPProowm/38qoJkZERKSa1CdGRMr6+OOPS5tdAcyaNYtdd911q3322WcfXn/9dZYvX87mzZuZMGFC6QhfxcXFPP3000Doe3LggQeSn5/Pbrvtxj//+U8gJEEffPDBNq89ZcoUZs2axQMPPICZMXjw4NJmag8//DDDhg0rN+4JEyZs1ZQMYPjw4bz66qsAvP7663Tt2hWAYcOG8d///peioiLWrVvH9OnT6datGzfffDNLlizhiy++4IknnuDQQw9NagIDSmJERESqTX1iRKSswsJCTj/9dLp3707v3r2ZO3cuY8aM2WqfNm3acPPNNzN48GD69OlD//79SxOMJk2aMGfOHAYMGMCrr77KNddcA8Bjjz3GuHHj6NOnDz169OD555+vNJZbb72Vu+++m86dO7NixQrOOussAN59992tOt5/8cUXLF68eJuhki+//HL+9a9/0atXL6644goeeOABALp168bQoUPp3bs3e++9N2effTY9e/bc7s+sKtScTEREREQkyQYMGMBbb70Vd9vUmKZpJ510EieddFLc/W644QZuuOGGrdbttttuvPTSS1WKZffdd2fq1Knk5eVttX7gwIGlCQlAp06d4nb6b9asGS+++GLcc19yySVccskl5b52SXO6ZFNNjIiIiIiIpBUlMSIiIiIidYz62FVMSYyIiIiI7JCqMvqX1K7q/m6UxIiIiFSTRicTqXtycnJYsWKFEpk6yN1ZsWIFOTk5230OdewXERGpJnefBEwqKCgYmepYRCRo3749S5YsYdmyZTX2Ghs2bKjWP+K1qa7FmpOTQ/v27bf7eCUxIiIiIrLDyc7OZrfddqvR15g6dSr9+vWr0ddIlnSKNRFqTiYiIiIiImlFSYyIiIiIiKQVJTEiIiIiIpJWlMSIiIiIiEhaURIjIiJSTRpiWUSkdimJERERqSZ3n+Tuo3Jzc1MdiohIvaAkRkRERERE0oqSGBERERERSSt1Kokxs6Fm9rGZLTSzy+NsNzO7M9r+oZn1L7M908zeN7MXai9qERERERGpTVmpDqCEmWUC9wA/AZYAM8xsorvPjdntCKBL9NgHuDf6WeIiYB6QXytBi4iIpIkj7/gvc5eu3rLipRcB6N4mn8kXHZSiqEREtk9dqonZG1jo7p+5+0bgCWBYmX2GAY94MA1oZmZtAMysPfBT4IHaDFpERCQd9O/YjOxM22pddqbRf9fmKYpIRGT71aUkph2wOGZ5SbQu0X3+ClwKFNdUgCIiIunqwiFdyLCtk5hMMy4c0jlFEYmIbL8605wMsDjrPJF9zOwo4Dt3n2lmgyp8EbNRwCiAli1bMnXq1O0ItXYVFhYqziRLl1gVZ/KlS6zpEqekj1b5OfxiQHuefHcxmzY72ZnGcQM70CovJ9WhiYhUWV1KYpYAHWKW2wNfJ7jPccDPzOxIIAfIN7NH3f2Usi/i7mOBsQAFBQU+aNCgpL2BmjJ16lQUZ3KlS6yKM/nSJdZ0iVMCMzsaOLpt27apDqVCFw7pwj9nLgFctTAiktbqUnOyGUAXM9vNzBoAJwATy+wzETgtGqVsX+AHd1/q7le4e3t37xQd92q8BEZERKQmpMtklyW1MaPffoqR7VEtjIikrTpTE+PuRWZ2PjAFyAQedPc5ZnZutP0+YDJwJLAQWAeckap4RURE0tHFe2ST+/aTNJz2BHx+MVx1FeRrUE8RSS91qSYGd5/s7l3dfQ93vylad1+UwBCNSjY62t7L3d+Nc46p7n5UbccuIiKSDlr03pP3HvsHduKJ8Mc/QpcucP/9sHlzqkMTEUlYnUpiREREpOZtbNkSxo+Hd94JSczVV8PatakOS0QkYUpiRERE6qu99oL//hemTw9NyoqK4OKL4dNPUx2ZiEiFlMSIiIjUZ2bQqVN4/sEH8MAD0L07XHYZrF6d0tBERMqjJEZERESCAQPgk0/gpJPUX0ZE6jQlMSIiIrJFmzbw0EPw7rvQtSvcdRd42bmnRURSS0mMiIiIbGvAAHjjDfjPfyArC374AU4/HRYuTHVkIiJKYkRERKQcZtCqVXg+cyY880zoL3PppSGpERFJESUxIiIiUrlDD4UFC+DUU+H220N/mb//XU3NRCQllMSIiIhIYtq0gXHjQn+Zbt1g0qRQWyMiUsuUxIiIiFSTmR1tZmMLCwtTHUrt6N8fpk6FCRPC8qefwnHHhZHNRERqgZIYERGRanL3Se4+Kjc3N9Wh1B4zyMsLz2fPhilToEcP+N3vYNWq1MYmIjs8JTEiIiJSPcOHh1qY006DP/859Jd54IFURyUiOzAlMSIiIlJ9rVuHxGXmzDCC2QcfpDoiEdmBKYkRERGR5OnXL/SXuf32sPzmm/Czn4WRzUREkkRJjIiIiCSXGTRsGJ4vWhSSmh494De/UX8ZEUkKJTEiIiJSc04+OdTCjBgBf/0rdO4M48enOioRSXNKYkRERKRmtW4N998P770HPXvC99+H9ZooU0S2k5IYERERqR19+8Jrr8FFF4XlRx+Fo4+Gjz9ObVwiknaUxIiIiEjtMYPMzPB8wwZ4/fVQO/PrX8PKlamNTUTShpIYERERSY2RI8P8MmeeCXfcEfrLTJiQ6qhEJA0oiREREZHU2WUX+Pvf4f33oXdvyMkJ64uLUxuXiNRpWakOQEREJJaZGXAysLu7X29mHYHW7v5OikOTmtSnD7z66pblG2+k1//9XxjJrKAgZWGJSN2kmhgREalr/gbsB5wYLa8B7kldOFJrzMIDYKedaDp7dugvc/HFW0Y0ExFBSYyIiNQ9+7j7aGADgLuvBBqkNiSpdeefz/R//APOOgvuugu6dIHnnkt1VCJSRyiJERGRumaTmWUCDmBmLQF1kKiHNjVvDvfdF/rLDBgAHTqEDRs3pjYwEUk5JTEiIlLX3Ak8C7Qys5uAN4E/pDYkSaneveHf/w6JDMA558CRR8K8eamNS0RSRkmMiIjUKe7+GHApcDOwFBju7v9MbVRSp/TuDW+9Bb16wYUXqr+MSD2kJEZEROocd5/v7ve4+93urtvtsrVf/zrMLzNyJNxzT5hf5uWXUx2ViNSiOpXEmNlQM/vYzBaa2eVxtpuZ3Rlt/9DM+kfrO5jZa2Y2z8zmmNlFtR+9iIgkg5k9bGbNYpabm9mDKYhjuJndb2bPm9lhtf36UomWLeHee2HWLDjwQOjePawvLExtXCJSK+pMEhN14rwHOALoDpxoZt3L7HYE0CV6jALujdYXAb91927AvsDoOMeKiEh66O3uq0oWotHJ+lXlBGb2oJl9Z2YflVlf4c2yWO7+nLuPBEYAx1fl9aUW9eoFEydCu3bgDkcdBUOHwty5qY5MRGpQwkmMmTU0s5PM7Eozu6bkkcRY9gYWuvtn7r4ReAIYVmafYcAjHkwDmplZG3df6u7vAbj7GmAe0C6JsYmISO3JMLPmJQtmthNVn5x5PDA0dkV5N8vMrJeZvVDm0Srm0KvRPDXpoQ04dnkAACAASURBVLgYhg2DadNCv5kLLoAVK1IdlYjUAHP3xHY0ewn4AZgJbC5Z7+5/SkogZscBQ9397Gj5VMJcAefH7PMCcIu7vxktvwJc5u7vxuzTCXgD6Onuq+O8zihCLQ4tW7Yc8NRTTyUj/BpVWFhIbm5uqsOoVLrECekTq+JMvnSJNV3iHDx48Ex3H5jMc5rZacCVQEln/l8Af3D3R6p4nk7AC+7eM1reDxjj7odHy1cAuPvN5RxvwC3Ay+7+nwpeR+VKDdneOLNXraLT+PG0nTSJosaNmX3rrazuXrMNNHb0z7S2Kc7kS5dYEy5X3D2hB/BRovtuz4NQSD0Qs3wqcFeZfV4EDoxZfgUYELOcS0iyjk3kNbt27erp4LXXXkt1CAlJlzjd0ydWxZl86RJrusQJvOs1UyZ0B86PHt238xydYssu4Lg45czdFRx/YVSm3Aecm8hrqlxJrmrHOXu2+8knuxcWhuVly9yLi6sdVzz15jOtJYoz+dIl1kTLlar0iXnLzHpVYf+qWgJ0iFluD3yd6D5mlg38C3jM3Z+pwThFRKQGmVlDoC+QD+wEHJek5ssWZ125zRHc/U53H+Du57r7fUl4faltPXvCo49Ckybw44+w775wxBEwZ06qIxORaqpKEnMgMDPqEPmhmc02sw+TGMsMoIuZ7WZmDYATgIll9pkInBaNUrYv8IO7L42q/McB89z9z0mMSUREat/zhD6QRcDamEd1JXKzbLuY2dFmNrZQI2PVXRkZcP75MH069OkTni9fnuqoRGQ7VaWj5BE1FgXg7kVmdj4wBcgEHnT3OWZ2brT9PmAycCSwEFgHnBEdfgChWcBsM5sVrbvS3SfXZMwiIlIj2rv70Mp3q7LSm2XAV4SbZScl48TuPgmYVFBQMDIZ55MakJ0NF18Mp5wCY8bAfffBY4+FSTO7dUt1dCJSRQknMe6+KBotpguQE7NpUbKCiZKOyWXW3Rfz3IHRcY57k/jNBEREJP28ZWa93H329p7AzCYAg4AWZrYEuNbdx8W7WZaUiCV9tGgBd98Nv/oVjB0LBQVh/ZdfQocOYPp3QiQdJJzEmNnZwEWE6vdZhPlY3gYOrZnQRESknjoQGGFmnwM/Em5Subv3TvQE7n5iOeu3uVkm9VSPHnDHHeH58uWhidnee8Of/xy2iUidVpU+MRcBewGL3H0wYeKxZTUSlYiI1GclExsfBhwNHBX9rLPUJybNNW0ampi9806YX2b0aPWXEanjqtInZoO7bzAzzKyhu883s4Iai0xEROql2mi+nGzqE5PmsrPhoou29Je59154/HGYNw9aty73sCPv+C9zl8ZMSffSiwB0b5PP5IsOquGgReq3qtTELDGzZsBzwMtm9jxJGtVFRESkRNR8+Q1C35Xrop9jUhmT1BM77wx33QUffgiXX74lgZkzB+JMDt6/YzOyM7fuQ5OdafTftXltRCtSryWcxLj7Me6+yt3HAL8nDGk8vKYCExGRekvNlyW1uneHyy4Lzz/+OPSXOewwmL31WBMXDulCRpmBADLNuHBI59qKVKTeSjiJieZmOcXMrnH31wmd+/vWXGgiIlJPbXD3DUBp82WgTjdfVp+YHdjuu8Nf/gIzZ0LfvnDeebAs5NSt8nP4xYD2pbUx2ZnGcQM70Covp6IzikgSVKU52d+A/YCSEV/WAPckPSIREanv0q75srtPcvdRubm5qQ5Fki07Gy64ABYuDBNkjh0LPXvCunXA1rUxqoURqT1V6di/j7v3N7P3Adx9pZk1qKG4RESknnL3Y6KnY8zsNaAp8FIKQxKBnXYKQzKfey5Mnw6NGwPQas77/KJ/Ox57Z7FqYURqUVWSmE1mlgk4gJm1BIprJCoREREgar4sUnd06xYeAK+/DoMGcc0hg1nW9zguHDIktbGJ1CNVaU52J/As0MrMbgLeBP5QI1GJiEi9Y2ZvRj/XmNnqmMcaM1td2fEitW7//eGuu2gw+wPuu+sCWl1yMXz3XaqjEqkXqjI62WPApcDNwFJguLv/s6YCExGR+sXdDzQzA3q4e37MI8/d81MdX0XUsb+eys4O/WQWLuSrY46BceNgv/1g8+ZURyayw6tKTQzuPt/d73H3u919Xk0FJSIi9ZO7O6HWP62oY38917w5C88/PwzBfNddkJkZEpkpU+LOLyMi1Vdpnxgzm1jRdnf/WfLCERERYZqZ7eXuM1IdiEiV7LlneAA88QSccgoMHhyGaO7TJ7WxiexgEunYvx+wGJgATAes4t1FRESqZTBwjpktAtYSyh13996pDUukCo4/HlatgmuugX794Oyz4YYbYJddUh2ZyA4hkSSmNfATwvwwJwEvAhPcfU5NBiYiIvXWEakOQKTasrJg9Gg46SS4/nq4+2748EOYNi3VkYnsECrtE+Pum939JXc/HdgXWAhMNbMLajw6ERGpd9x9EbAa2AXYNeYhkn6aNw/NyT76CO68M6xbvRqef179ZUSqIaGO/WbW0MyOBR4FRhOGW36mJgMTEZH6yczOBt4ApgDXRT/HpDKmymh0MqlUQQHsvXd4PnYsDB8OQ4bABx+kNi6RNFVpEmNmDwNvAf2B69x9L3e/wd2/qvHoRESkProI2AtY5O6DgX7AstSGVDGNTiZVcvHF8Le/heZl/frBqFHw7bepjkokrSRSE3Mq0JVQqLylycdqz3Pvf8UBt7zKiJfWcsAtr/Lc+8obRaRe2ODuGyC0BHD3+UBBimMSSZ6sLPjVr2DhQvj1r+Ghh8KyiCSs0o797l6luWQkOZ57/yuueGY26zeFCbO+WrWeK56ZDcDwfu1SGZqISE1bYmbNgOeAl81sJfB1imMSSb5mzeBPf4JzzoGM6N+tRYvg3Xfh2GPBNCCsSHmUoNRRt035uDSBKbF+02b+MHkemzYXpygqEZGa5+7HuPsqdx8D/B4YBwxPbVQiNahrV+jcOTy/5x447rgwv8z776c2LpE6LJEhliUFvl61Pu7679b8SPdrXqJzqzy6tcmjW+t89myTR7c2+bTIbVjLUYqIJI+Z3Q087u5vlaxz99dTGJJI7fvDH2D33eH3v4cBA+DMM+HGG6F161RHJlKnqCamjmrbrFHc9c0bZ3PmgbvRKq8h/1u4nJsmz+PUce9wyT+3jG5yz2sLmfbZitoKVUQkWT4B/mRmX5jZrWbWN9UBidS6rCw491z45BP4zW/gkUfgpptSHZVInaOamDrqksMLtuoTA9AoO5Nrj+6xVZ+Y79duZP7S1TTICvnohk2buevVTzhvUGf23X1nVq7dyAljp9GtTR57tslnz9Z5dG+TT8u8hpja2opIHeLudwB3mNmuwAnAQ2aWA0wAnnD3BSkNsAJmdjRwdNu2bVMdiuwomjWD228P/WWaNQvrZswIfWZ+/nP1l5F6L6EkxsyaA0cDxxBGKvsceB6Y6O4aE7AGlCQqt035mK9Wradds0ZccnjBNp36d2rSgP07tyhdzsnO5KMxh7Mx6jdT+GMR7Zo3Yvrn3/PcrK+3Oq5bmzz2bB0Sm4O6tKR105xaeGciIhWLJru8FbjVzPoBDwLXApkpDawC7j4JmFRQUDAy1bHIDqZLly3P77kHHn4YDj44TKDZv3/q4hJJsUqTGDN7BmgOvAhc5u4LzKwjMAz4h5k1cPdBNRtm/TS8XzuG92vH1KlTGTRoUMLHZWVmkJUZamY67NSYB0fsBcCqdRuZ/80a5i1dzfyla5j/zWoem76IDZuKue+U/gxt2obZS35g7H8/49LDC+iwU2M2bS4mK8NUayMitcbMsoGhhNqYIcDrhEkvReq3Bx6A/faDq6+GgQPhjDNCf5k2bVIdmUitS6Qm5kx3XxW7wt2/BO4C7oqGwZQ00KxxA/bdfWf23X3n0nWbi50vVqylVV4YFOC7NRt4b9FKsqMk6ME3P+fe1z9lz9ah1qZ7mzCQQNdd8sjJrrM3RUUkDZnZT4ATgZ8C7wBPAKPcfW1KAxOpK7KyQvOyE04Iycsdd0BBAVx6aaojE6l1icwTs8rM9iTUvLQDnDBe/0R3n1c2wakOMxsK3EFoMvCAu99SZrtF248E1gEj3P29RI6V+DIzjD1abplheki3XRjSbZfS5e5t8zmiZxvmLV3NkzMWl/bRyTDo1KIJ3drk0611HqMO3qPWYxeRHc6VwOPA79z9+1QHI1JnNW0Kt90WEpr27cO6F16A9evD8MxqPSH1QCLNyS4j3Bl7gnBnDKA9MMHMnkhWsmBmmcA9wE+AJcAMM5vo7nNjdjsC6BI99gHuBfZJ8FjZDgd1aclBXVoCUFzsfPn9OuZ/s5q5S9cwf+lqZi/5gTc/Wc7owWF8+zET5/Ddmg387eQBAHyxfC2t8hvSuIHGkNgRPff+V1v6bU17NW6/LZFEufvgVMcgklZK5pYBGDsWJk2CAw+Ev/41DM8ssgNL5D/Ls4Ae7r4pdqWZ/RmYAySrxmNvYKG7fxad/wlC7U9sIjIMeMTdHZhmZs3MrA3QKYFjpZoyMoxOLZrQqUUThvbc0v52w6bNpX1mWuU3JCtjyx2gMx+ewefL19Jp5yalTdK6RfPatG/eSH1t0thz73+11Qh6X61azxXPzAZQIlMNSgxFZLs8+yw8+CBcdRXstRecfnoYmlkj5skOKpEkphhoCywqs75NtC1Z2gGLY5aXEGpbKtunXYLHAmBmo4BRAC1btmTq1KnVCro2FBYWpk2c3XOXQC5MnfodAEd3KOLLptksXrOB9z5bx0sffYNH++dkQoe8DPZuk8VPds0G4MfNTsPMmk9s0ukzrQtxujsbNsP6Imf9JlhX5Nz5/gbWb9p6v/WbNnPD8x+w/quPWbhqMxkGmWZkWGiCmJkBBmRaaMq4W9MMGmUZq390lm8opmNeBlkZxuqNztqNvmX/DKJzGJlG6fkaZFDlRLiufKbxvPX1JsZ/tJGN0ZX1q1XrufSfs5g7by77t81ObXAiUrdlZsLIkfDLX4YJM//6Vxg6FI4/PtWRidSIRJKYi4FXzOwTtiQKHYHOwPlJjCXefyKe4D6JHBtWuo8FxgIUFBR4VUb9SpWqjk6WKvHiHFRmn7U/FrHg2zXMi0ZHm7d0NTu3bcGgQV3ZsGkzvcZM4XeHFXDOIXuwbmMRbyxYxp6t8+m4U2MyMpKX3KTzZ1pV7s66jZtZs6GINRs2sTr6uWZDEd3a5NO5VS5Lf1jPvVM/5fi9OtCjbVNmfPE91zw/J+y/fhOFPxZRHPcvalvfb3CKW+7BuDc/qnTfSecfSK/2TXl8+pdc/+xspl85hF3yc/jLywu4481PKj2+ZP87/vMJd776CZ/ceAQZGcb1k+byzPtLyMowMjOMTDMyM42sjAw2rM8gPzeDjAxj8oUHYmbc9/qnvLdoJWNPGwjAX/+zgNlLfiAjw7acI3qULDdt1IDLj9gTgKfeXcy6H4sYccBuADw540uWF27c6tisDIs5XwY7N2nA4D1bAfDWp8tplJ3Ji9PeL01gSmwshhe/zOTKkwYl9gsQkfqtaVO49VYYPRo6dAjr7r8/rP/FL1Ibm0gSJdKx/yUz60po7tWOkDAsAWa4++YKD66aJUCHmOX2hAEEEtmnQQLHSh3QpGEW/To2p1/H5ttsKyp2Ljy0CwM7hW1zv17NuY++B0DjBpkUlI6QFibuLGidR37Ojn132t1Z+2NR3ARkzYYiuuySy16ddmLdxiKufvYjju7TlsF7tuKL5Ws59cHprF5fROGPRWwuJwO5+qfd6Nwql/UbNzPxg685sHMLerRtSuMGmbRr1oj8nDzycrLIb5RNXk4WeTlbfv7uqQ9YVvjjNuds26wRw/u24+AuLSl2p6jY2VzmUVTsFLuze8smABxS0JIHRwykaaPw+zyyVxt2b9lky77F256nqNjJbRguYQM7NedXh+xRmuj26dCUouLirV8v+rn02w3svHMTNruX1uJkmpEVUwO4en0R367ZQNFmj/seioqdnZtsSWL+M/dbVqzdWJrEPPzWIuYuXV3h77Z3+6alScyNL8yjbbNGfL1qfdx9y1u/I0rXeck02aXUOR07hp/u8Mgj8OabcOed5J16KqTBTTyRyiTU29rdi4FpNRzLDKCLme0GfEWYH+CkMvtMBM6P+rzsA/zg7kvNbFkCx0odl9swiwuGbJnUq2e7pjw/+oCoxibMbzN59lImvPNl6T7tmjXiT7/sw76778zKtRtZuW4ju+7chMxyam1qs7+Bu7N+U9kakC1JyOr1m2jfvDE/7R36F1044X326tScU/frxPqNm9nvlldYvX4TxVOmlPsap++3K3t12omsjAze+eJ79tptJwByc7IYuOtOUcKRRX5OdkwCEpKQ/JwsdokmON29ZS6zrjms9Lw92jblgdMHVvj+rvppt636xAA0ys7kksMLaNIwiyYNEx/MoV2zRrRr1qh0uaB1HgWt8xI+/oDOLTggZtLXYX3bMaxv/N9rqN3ausPryIN332r5mqO7J/zaQGkNTomJ5x/AZt82gYpNhGK/o3ed1I+sDGPe0tV8FSdhaRvz2ezI0nleMk12KXWWGUydCg89BFddxYBzz4W33w5NzpR0SxpLZHSyjgmea5W7V3zrsQLuXmRm5wNTCMMkP+juc8zs3Gj7fcBkwvDKCwlDLJ9R0bHbG4vUDTnZmfTp0Iw+HbZMReTufLN6A/OXrmHu0tXM/2YNu+SHf8RfmvMNVzwzmzcuGUzHnRvzv4XLWfhdYemAAq99/F2VOqJv2LSZ1eu3rf0ICUlYbtoom7MPCv8AX/b0h+TlZHH1UeEf4H1vfoVvV29bUxHr0D1blSYx36/dyJofi6L3nsHP+rTl+2+/pmfBHlvVguTHPG/WqAEADbIyePOyQ0vP2yK3IX85vm/VP/QqKPnMSpPCZo3UCT2SlZmR2B2iSMkw55ccXlBuYlhPaF4ykZqQmQlnnw2//CVfnnsuHZ98Es47T0mMpLVEytmHE9jHgfHAI9UJxt0nExKV2HX3xTx3YHSix8qOx8xo07QRbZo2Km2KU+LAzi247bjetG8e7lpPmfMNj7y9ZTyKTIPNZVpVrd+0mdumfMzwfu248YW5fL58LeNG7AXACWOnMWtx+dMgmUHvdk1Lk5iG2Rk0yMoo3X7WgbtRVOxRLUhW6c/YGpEmMUNPP3r2PjHnNq4f1pOpU5cz6JC6OwfP8H7tGN6vXdr0Marr6ntiWJvzkonUS/n5fDZqFB3vvBNaRLXX11wD3buHAQA0YqikkUSSmHOAT6IEQqTO6rBTYzrs1Lh0+bqf9WD04M7Mi2psbvm/+XGPK+lv0LppDptjvuZnHbgbq9Zvimo+tu4Pkh8lILGDDVw/rOdW59UEoLI96nNiWFvzkonUeyUJzMaNMHky3HAD3HVXGNFsr71SG5tIghJJYp4BOpjZAmA28GHJT3dfVpPBiVSHmbFLfg675OcwqKAV/3h7UYX9DUpqVEoc3UfV7CK1rLbmJRMRgAYNYPp0GD8+zC+z995w2mlhdLPWrVMdnUiFMirbwd17Aq2A8wgjxuwBXAnMNrNvajY8keS55PACGmVnbrWunvU3EKnrSuYlKyvZ85KJSInMTDjrLFiwAC6/HCZODDU0InVcoqOT/QjMMLNCd7+gZH00FKZIWqjv/Q1E0kBtzUsmImXl58PNN4camdzcMDTzmWfCT34CJ56o/jJS51RlAB0oM4Gku69MYiwiNa4+9zcQqetqcV4yESlPbhgtkVWr4IMPQlOzkv4y++xT4aEitanS5mRmdreZnWVm/QgFioiISI1w92J3n+bu/3L3p6PnSmBEalvz5jBjBjz4IHzxBey7L5x6KixfnurIRIDEamI+BPoBpwF5ZjaX0MFyLjDX3Z+swfhERKSeqK15yUQkQZmZcMYZcNxxcMst8Pjj0LBhqqMSARJIYtx9bOyymbUHegO9gKMAJTEiIpIMtTYvmYhUQV4e3HQTXHttGNFs0yY48kgYMSL0l8motGGPSNJVtU8M7r6E0EZZE0uKiEgyaV4ykbqsQYPw89tvYeVKOOWULf1l9t03tbFJvZNIn5iOCT7yayNgERHZYT0DrDKzGWb2oJldbGZDzKxlqgOrjJkdbWZjCwsLUx2KSM1r3x7eeQceeggWLYL99oOTT4bVauUptSeRmhhV74uISI1z955m1pDQZHkysJYwP1kPM8Pd6+zse+4+CZhUUFAwMtWxiNSKjIzQnKykv8wrr0CTJmGbu4ZklhqXSJ+YwbURiIiIiOYlE0kzublw441w3XVhIICVK2HwYLjkEvWXkRqV0DfLzPY0s8vM7E4zuyN6vmdNByciIvWW5iUTSSeZmeHnsmWQnR36y+y/P0ybltq4ZIeVSJ+Yy4AnCHPEvAPMiJ4/YWaX12x4IiJSX2heMpEdQNeuMH06PPwwfPnllv4yGzemOjLZwSTSJ+YsoIe7b4pdaWZ/JswXc0tNBCYiIvWO5iUT2RFkZMBpp8Gxx8If/wiffLJlZLPNm7fU2ohUQyLNyYqBtnHWt4m2iYiIVJu7j3X38939EHdvARwGPASsI8xLJiLpJDcXrr8+TJIJIZnp3BkeeQSK9S+kVE8iNTEXA6+Y2SfA4mhdR6AzcH5NBSYiIvWb5iUT2UGUjFS2YQO0bAmnnw533x3ml9l//9TGJmkrkdHJXjKzrsDeQDtCO+UlwAx331zD8YmISD1hZh0T3HWVu2tCCpF006tX6Oj/2GNw+eVwwAFw6qmh/4yGZJYqqjSJMbMMdy8G4g4vEbNdRESkOjQvmciOLiMjJC4l/WU2bty6piYnJ7XxSdpIpDnZy2a2HHgOeNHdV5tZY2AocAzQk9ARU0REZLtpXjKReqRJkzC3TInXXgvDMv/hDyHJEalEIs3JhphZd2AY8KKZNSB06J8C/MXd36vhGEVEpJ6I5iAbRmi+7MDXwPPuPj+lgYlIzcrPh/btYcQIuPtu8k87DQYNSnVUUoclNNmlu89195vd/SDgEHffz93HKIEREZFk0bxkIvXYgAHw9tvwj3/A0qX0v/BC+NWvUh2V1GGJNCcr60ozywRmAbPc/ZMkxyQiIvWT5iUTqc8yMkKTsmOO4YvRo+nUt29YX1wM69aFIZtFIgnVxMRy92uAO4E1wM/N7P6kRyUiIvWR5iUTEWjShC9GjIBzzgnLjzwCXbvC+PGaX0ZKJTI6WSdgNLAH8D2hBmaSu78EvFSTwYmISL2ieclEZFs9ekDHjnDGGWF+mb/8BQ46KNVRSYolUhPzPDAfuAf4CdAHeMPM7jGzhjUZnIiI1B/RzbGuwHWEwWP+DYwBCqJtIlIf7bUXvPUWPPoofPMNHHwwXHJJqqOSFEukT0ymu48DMLPv3X2kmWUBvwbGAqfXZIAiIlI/aF4yESlXRgacfDIMHw633w4DB4b169bB5s2Ql5fa+KTWJVIT8x8zK6nGdwB3L3L324D9khGEme1kZi+b2SfRz+bl7DfUzD42s4WxI9WY2W1mNt/MPjSzZ82sWTLiEhGRWvWymT1pZieaWT6AmTU2s2PN7B/AzNoMxsy6mdl9Zva0mWmYJJG6oEkTuPZa+OlPw/Itt4T+Mg89pP4y9UwiScxvgKZm9i7QzsxGmdkpZnYPsCJJcVwOvOLuXYBXouWtRCOi3QMcAXQHTozmrwF4Gejp7r2BBcAVSYpLRERqibsPITQl60SYl2w6oUzoTZiXLOGJlc3sQTP7zsw+KrM+7s2wcuKZ5+7nAr8EBlbx7YhIbfjpT6FTJzjzzNDs7I03Uh2R1JJKkxh3L3b3m4CDgZFAa6A/8BEhoUiGYcDD0fOHgeFx9tkbWOjun7n7RsJcAsOiGP/t7kXRftOA9kmKS0REalES5yUbDwyNXVHezTAz62VmL5R5tIqO+RnwJiGZEpG6Zp99Qn+Zxx+HZcvgkEPgpptSHZXUAnP3yncKHfgvBfYHCoH3gKfc/dOkBGG2yt2bxSyvdPfmZfY5Dhjq7mdHy6cC+7j7+WX2mwQ86e6PlvNao4BRAC1bthzw1FNPJeMt1KjCwkJy02Bs9HSJE9InVsWZfOkSa7rEOXjw4JnuXiO1FGZ2PbDd85JFo2u+4O49o+X9gDHufni0fAWAu9+cwLledPeflrNN5UoNSZc4IX1i3ZHjzNiwgQ5PPcXy/fdnbefOZP/wA8XZ2Wxu3LiGokyfzxPSJ9aEyxV3r/RBmBfmAcLIZH8BbgdeB05J5PjoHP8h1N6UfQwDVpXZd2Wc438BPBCzfCpwV5l9rgKeJUrOKnt07drV08Frr72W6hASki5xuqdPrIoz+dIl1nSJE3jXEywHtucB7EKoUbkcuL+Kx3YCPopZPi5OOXJ3BccPisq/vwOjE3lNlSvJlS5xuqdPrPUqzlNOcd9lF/dx49yLiqp/vjjS5fN0T59YEy1XEhmdjCh5Gebuq8xsb3c/IKqdmQrErfGIkyz9v/K2mdm3ZtbG3ZeaWRvguzi7LQE6xCy3B76OOcfpwFHAkOgDEBGRNFIL85JZnHXllhfuPpVQzolIOrrgAvj0UzjrrDC/zF//GoZnlh1CIh37AW6L2Xe5mf2ZMLRysoaBmMiWoZpPJ8xNU9YMoIuZ7WZmDYATouMws6HAZcDP3H1dkmISEZHaVdPzklV4M0xEdjB77w3/+x9MmADLl4f+Mn/7W6qjkiRJKIlx9xfc/fto8RfAu0Bu9DwZbgF+Es3S/JNoGTNra2aToxiKCDM2TwHmEfrkzImOvxvIIwzPOcvM7ktSXCIiUnsy3X2cu78CfO/uIwm1Ml8Q5iWrrnJvhlWXmR1tZmMLCwuTcToRSRYzOOEE+Pjj0OH/mGPC+s8/h9WrUxubVEuizclKeRgZ7PFkBuHuK4AhcdZ/DRwZszwZmBxnv87JjEdERFLiP2Z2vrvfTcy8ZMBtZragKicyswmEPi0tzGwJcK27j4vmPZtCGDDgwZibpa2/lgAAEiZJREFUYdXi7pOASQUFBSOTcT6R+ujIO/7L3KUxicVLLwLQvU0+ky86qHon///t3XuQXGWZx/Hvk0kgIZAClUAgUUAG3MglDBFcFQQCLCAEEChhdZe11CgIAZFyuZSrq6XLsuiui4gbhYUtFMgiysUsEJBwqwKVQIpcsEDwEglXEQzLyu3ZP85BJpOeySTTPeeczPdTNdXdp7tP/ybl8Pj0+77nHTcOzjrrjcfHH/9GY/PRj0JX19DOr2E32OlkkiR1Wtv2JcvM4zJzUmaOyczJmXlReXxeZu6QmW/PYvsASTXR89ZNGdO16tK1MV1Bz9ta7oE+NF/7Gmy/PXziE7D77rBgQfs/Qx1lEyNJqoUcnn3JOsLpZNLQzZ7RzahYtYnpimD2jA5MuHnXu+DOO+GKK+DZZ2HffeHKK9v/OeoYmxhJUm2UC/g/C5wA7Aw8BdyUmX+oNNgaZOZ1mTmrCXswSHU1ccJYjtl98p9HY8Z0BUdPn8LETcZ25gMj4EMfggcfLEZmZs4sji9a5HqZBrCJkSTVyb8Ab6PYF2Y58Gbg4oj4SKWpJA2L3qMxHRuF6WvcODjttOL21VfhqKOguxu+853isWrJJkaSVCe7Aqdn5iJgj8w8HTiQYv8YSeu510djAjo7CtOfrq5iWtkOO8CsWdDTA7feOrwZNCg2MZKkOun0vmSSam72jG66Nxs1PKMwrey+O9x+O8ydC889B/vtZyNTQzYxkqTaGIZ9yTrChf1S+0ycMJaz9hw3/KMwvUXAMcfAsmXFtLL3v784ftttRWOjytnESJJqKTNfyszvZ+bXy33DasuF/dJ6atw4+PjHYdQoeOEFOOKIYr3MnDmul6mYTYwkSZK0JuPHwy23wDveAZ/8JPT0sOnChVWnGrFsYiRJkqTB6OkpppRddRU8/zzTPvtZWLq06lQjkk2MJElD5JoYaQSJKC7DvGwZi7/8ZZg6tTh+9dXwh1pvabVesYmRJGmIXBMjjUBjx/L0+95X3F+xAo49tlgv8+1vwyuvVJttBLCJkSRJkoZi0iS4++5iVOaEE2C33Yr1M+oYmxhJkiRpqHp6YMGCYr3MCy/ABz4Ajz9edar1lk2MJEmS1A6vr5dZuhRuvBG23LI4PmeO62XazCZGkiRJaqexY9/YIHPxYvjUp2D77eHCC10v0yY2MZIkDZFXJ5PUr512goULi9sTT4Rp02D+/KpTNZ5NjCRJQ+TVySQNaNo0uPXW4jLML74IH/5wsW5G68wmRpIkSeq0CDjyyGK9zPz5MH58MbXsq1+FZ5+tOl3j2MRIkiRJw2XDDWHXXYv7d94Jn/98sb/MBRe4XmYt2MRIkiRJVdhnn2K9zC67wEknFc3NTTdVnaoRRlcdQJIkSRqxdt212Bjzmmvg9NPhtNNg0SLo6hryqQ/5xh0sXfH8Gwdu+DEAUydNYN4pew35/FVyJEaSJEmqUgQccQQsWQLXXls0MM89B2eeOaT1Mj1v3ZQxXbHKsTFdQc/bNhtq4srZxEiSNEReYllSW2y4IWy3XXH/5pvh3HOL/WXWcb3M7BndjIpVm5iuCGbP2L4daStlEyNJ0hB5iWVJbXfUUXDffcXlmV9fL3PjjWt1iokTxnLM7pP/PBozpis4evoUJm4ythOJh5VNjCRJklRHu+xSjMhccw289BJ84xtrfYreozHryygM2MRIkiRJ9RUBM2cW62UuuaQ49uijcOqp8Pvfr/Htr4/GBKw3ozBQkyYmIt4UEfMj4qHytuVqo4g4KCJ+EREPR8QZLZ4/PSIyIt7S+dSSJEnSMNlgA5g4sbj/k5/A+ecX62XOPx9efnnAt86e0U33ZqPWm1EYqEkTA5wB3JKZ3cAt5eNVREQXcAFwMDAVOC4ipvZ6fgpwAPCbYUksSZIkVeFjH4P774eeHpg9u5h2dsMN/b584oSxnLXnuPVmFAbq08QcDlxa3r8UOKLFa/YAHs7MRzLzJeCK8n2v+1fgc0B2MqgkSZJUuZ13hvnzi0syv/oqXHdd1YmGVV2amC0ycwVAeTuxxWu2Bn7b6/Hy8hgRMRP4XWYu6nRQSZIkqRYi4LDDYPFiOOec4thdd8HJJ8Mzz1SbrcNGD9cHRcTNwJYtnjp7sKdocSwjYqPyHAcOMscsYBbA5ptvzoIFCwb58dVZuXKlOdusKVnN2X5NydqUnJKkGthgg+IH4J574Fvfgssugy9+EU48EcaMqTReJwxbE5OZ+/f3XEQ8ERGTMnNFREwCnmzxsuXAlF6PJwOPAW8HtgUWRXH5uMnAwojYIzMfb5FjDjAHYMcdd8x99tlnHX+j4bNgwQLM2V5NyWrO9mtK1qbkVCEiDgMO22qrraqOImmkO+00OPBA+MxniiuYXXhhcWnmDTesOllb1WU62bXA8eX944FrWrzmZ0B3RGwbERsAxwLXZuYDmTkxM7fJzG0omp2eVg2MJEmd4GaXkmplp53gppuKdTKvvVZMN1vP1KWJOQc4ICIeorjC2DkAEbFVRMwDyMxXgJOAG4FlwNzMXFJRXkmSJKm+IuDQQ4sG5uSTq07TdsM2nWwgmfkMMKPF8ceAQ3o9ngfMW8O5tml3PkmSJKmRXl8rs56py0iMJEmSJA2KTYwkSZKkRrGJkSRJktQoNjGSJEmSGsUmRpIkSVKj2MRIkiRJahSbGEmSJEmNYhMjSZIkqVFsYiRJkiQ1ik2MJElDFBGHRcSclStXVh1FkkYEmxhJkoYoM6/LzFkbb7xx1VEkaUSwiZEkSZLUKDYxkiRJkhrFJkaSJElSo9jESJIkSWoUmxhJkiRJjWITI0mSJKlRbGIkSZIkNYpNjCRJkqRGsYmRJEmS1Cg2MZIkSZIaxSZGkiRJUqPYxEiSJElqFJsYSZIkSY1iEyNJkiSpUWxiJEmSJDWKTYwkSZKkRrGJkSRJktQotWhiIuJNETE/Ih4qbzfr53UHRcQvIuLhiDijz3Mnl88tiYhzhye5JGl9FhHjI+LeiDi06iySpDfUookBzgBuycxu4Jby8Soiogu4ADgYmAocFxFTy+f2BQ4HdsnMdwLnDVdwSVL9RMTFEfFkRCzuc7zfL8P68ffA3M6klCStq7o0MYcDl5b3LwWOaPGaPYCHM/ORzHwJuKJ8H8AJwDmZ+SeAzHyyw3klSfV2CXBQ7wP9fRkWETtHxPV9fiZGxP7AUuCJ4Q4vSRrY6KoDlLbIzBUAmbkiIia2eM3WwG97PV4O7Fne3wHYKyK+AvwfcHpm/qzVB0XELGBW+fBPfb+lq6m3AE9XHWIQmpITmpPVnO3XlKxNyblj1QFayczbI2KbPof//GUYQERcARyemf8ErDZdrBzlH0/R8LwYEfMy87UWr7OudE5TckJzspqzvZqSE5qTdVB1ZdiamIi4GdiyxVNnD/YULY5leTsa2Ax4N/AuYG5EbJeZudobMucAc8pMP8/M6YP8/MqYs/2aktWc7deUrE3KWXWGtTDQl2GrycyzASLi74CnWzUw5eusKx3SlJzQnKzmbK+m5ITmZB1sXRm2JiYz9+/vuYh4IiImlaMwk4BW08GWA1N6PZ4MPNbruavLpuWnEfEaRbf5VHvSS5LWAwN9GdavzLyk/VEkSUNRlzUx1wLHl/ePB65p8ZqfAd0RsW1EbAAcW74P4EfAfgARsQOwAc0YLpMkDZ+BvgyTJDVIXZqYc4ADIuIh4IDyMRGxVUTMA8jMV4CTgBuBZcDczFxSvv9iYLtyHvIVwPGtppK1MKe9v0bHmLP9mpLVnO3XlKzmbL+Bvgxrl6b8e5iz/ZqS1Zzt1ZSc0Jysg8oZg/v/+pIkNUdEXA7sQzG1+AngC5l5UUQcAvwb0AVcnJlfqS6lJGld2cRIkiRJapS6TCeTJEmSpEEZkU1Mfzs5101ETImIWyNiWUQsiYhTqs7USkSMjYifRsSiMuc/Vp1pIBHRFRH3RcT1VWcZSET8KiIeiIj763wZ24jYNCKuiogHy/+t/mXVmfqKiB3Lf8fXf56PiFOrztVKRHym/DtaHBGXR8TYqjP1JyJOKXMuqeu/53CxrrSXdaX9mlJTwLrSbk2pK2tbU0bkdLKI2BtYCfxXZu5UdZ7+lJebnpSZCyNiE+Be4IjMXFpxtFVERADjM3NlRIwB7gROycy7K47WUkScBkwHJmTmahvc1UVE/AqYnpm1vtJeRFwK3JGZ3y0XS2+UmX+oOld/oti1/XfAnpn566rz9BYRW1P8/UzNzBcjYi4wr46X+I2InSgupLIH8BJwA3BCZj5UabCKWFfay7rSfk2pKWBdaaem1JV1qSkjciQmM28Hfl91jjXJzBWZubC8/0eKq7JtXW2q1WVhZflwTPlTy+44IiYDHwC+W3WW9UFETAD2Bi4CyMyX6lxoSjOAX9at0PQyGhgXEaOBjajvJYD/Arg7M/+3vHrkbcCRFWeqjHWlvawrI5d1pSOaUFfWuqaMyCamiSJiG2A34J5qk7RWDqXfT7FR6fzMrGVOiqsSfQ5oufN2zSRwU0TcGxGzqg7Tj+0oNpX9z3IqxXcjYnzVodbgWODyqkO0kpm/A84DfgOsAJ7LzJuqTdWvxcDeEfHmiNgIOIRV92BRzVlX2qYpdaUJNQWsK23VoLqy1jXFJqYBImJj4AfAqZn5fNV5WsnMVzNzGsXmcXuUw4K1EhGHAk9m5r1VZxmk92ZmD3Aw8OlyukrdjAZ6gAszczfgBeCMaiP1r5yWMBP476qztBIRmwGHA9sCWwHjI+Ij1aZqLTOXAf8MzKcY9l8EvFJpKA2adaU9GlZXmlBTwLrSVk2pK+tSU2xiaq6cC/wD4HuZeXXVedakHPJdABxUcZRW3gvMLOcFXwHsFxGXVRupf5n5WHn7JPBDinmidbMcWN7rG9KrKIpPXR0MLMzMJ6oO0o/9gUcz86nMfBm4GnhPxZn6lZkXZWZPZu5NMZVqRK6HaRrrSls1pq40pKaAdaXdGlNX1ram2MTUWLmw8SJgWWZ+veo8/YmIzSNi0/L+OIo/mAerTbW6zDwzMydn5jYUQ78/yczafRsBEBHjy0W3lMPoB1IMtdZKZj4O/DYidiwPzQBqtUC4j+Oo6ZB/6TfAuyNio/LvfwbFmoVaioiJ5e1bgQ9S739bYV1pt6bUlabUFLCudEBj6sra1pTRwxGqbqLXTs4RsZxyJ+dqU7X0XuBvgAfKecEAZ2XmvAoztTIJuLS8OscoYG5m1vYykw2xBfDD4r83jAa+n5k3VBupXycD3yuH1B8BPlpxnpbKObYHAJ+sOkt/MvOeiLgKWEgxjH4fMKfaVAP6QUS8GXgZ+HRmPlt1oKpYV9rOutJeTaopYF1pm4bVlbWqKSPyEsuSJEmSmsvpZJIkSZIaxSZGkiRJUqPYxEiSJElqFJsYSZIkSY1iEyNJkiSpUWxipA6IiMkRcU1EPBQRj0TENyNiw0G8b2U/x78UEfuX908tL+s40Hn+KiK+GBGbRUTdLp0qSVpL1hVpVTYxUpuVm0ldDfwoM7uBbmAccO66njMz/yEzby4fngoMWGyAvYA7gL2Bu9b1cyVJ1bOuSKtznxipzSJiBsVGd3v3OjYB+DUwBTgamJ6ZJ5XPXQ+cl5kLym/M/gPYF3gWODYzn4qIS4Drga2A84BfAE9n5r59PvtDwJnAduXnbQE8DyzNzJmd+60lSZ1iXZFW50iM1H7vBO7tfSAznwd+BWy/hveOBxZmZg9wG/CFPuf5d+AxYN++haZ8/kqgB1icmTsDi4HdLDSS1GjWFakPmxip/QJoNcQZg3jva8CV5f3LgPetw+d3A78s72+UmX9ch3NIkurDuiL1YRMjtd8SYHrvA+Ww/xYUw/WvsOrf3tgBzrVW8z0j4ufAjcC+EbEU2DEi7o+IvdbmPJKkWrGuSH3YxEjtdwuwUUT8LUBEdAFfA76ZmS9SDP9Pi4hRETEF2KPXe0dRzG0G+Gvgzhbn/yOwSasPzszpwI+BwykWfJ6dmdMy844h/1aSpKpYV6Q+bGKkNsviahlHAkdHxEPAM8BrmfmV8iV3AY8CD1AsplzY6+0vAO+MiHuB/YAvtfiIOcD/RMSt/UToAe6nuJLMbUP8dSRJFbOuSKvz6mRSh0XEe4DLgQ9m5r1rer0kSQOxrkg2MZIkSZIaxulkkiRJkhrFJkaSJElSo9jESJIkSWoUmxhJkiRJjWITI0mSJKlRbGIkSZIkNcr/AwWYd+9nj51CAAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -524,7 +524,7 @@ "plt.plot(n, means, \"o-.\")\n", "plt.xlabel(r\"Qubit #\")\n", "plt.ylabel(r\"$ \\partial \\theta_{i} \\langle 0|H |0\\rangle$ Mean\")\n", - "plt.title(\"Mean of {} sampled graident\".format(samples))\n", + "plt.title(\"Mean of {} sampled gradient\".format(samples))\n", "plt.xlim([1,9])\n", "plt.ylim([-0.06, 0.06])\n", "plt.grid()\n", @@ -541,7 +541,7 @@ "plt.semilogy(n, np.exp(n * slope + intercept), \"r--\", label=\"Slope {:03.4f}\".format(slope))\n", "plt.xlabel(r\"Qubit #\")\n", "plt.ylabel(r\"$ \\partial \\theta_{i} \\langle 0|H |0\\rangle$ Variance\")\n", - "plt.title(\"Variance of {} sampled graident\".format(samples))\n", + "plt.title(\"Variance of {} sampled gradient\".format(samples))\n", "plt.legend()\n", "plt.xlim([1,9])\n", "plt.ylim([0.0001, 0.1])\n", diff --git a/tutorial/qnn_research/Gradient_CN.ipynb b/tutorial/qnn_research/Gradient_CN.ipynb new file mode 100644 index 0000000..a6840e7 --- /dev/null +++ b/tutorial/qnn_research/Gradient_CN.ipynb @@ -0,0 +1,917 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "interesting-deployment", + "metadata": {}, + "source": [ + "# 使用量子电路计算梯度\n", + "\n", + " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " + ] + }, + { + "cell_type": "markdown", + "id": "sweet-olympus", + "metadata": {}, + "source": [ + "## 概览\n", + "\n", + "当使用像[变分量子本征求解器 (VQE)](../quantum_simulation/VQE_CN.ipynb) 和 [量子近似优化算法 (QAOA)](../combinatorial_optimization/QAOA_CN.ipynb) 这样的变分量子算法时，我们需要改变量子电路中的参数使目标函数最小化。这就带来了一个重要的问题 - 如何计算参数化量子电路的梯度？由于目标函数是使用量子电路评估的，因此也必须使用量子算法评估其梯度。与经典计算梯度相比，这无疑更具挑战性。下面我们将介绍三种在量子计算机上完成这项任务的方法。同时利用 Paddle Quantum 模拟它们在量子计算机上运行的效果。" + ] + }, + { + "cell_type": "markdown", + "id": "spectacular-orientation", + "metadata": {}, + "source": [ + "## 背景\n", + "\n", + "假设目标函数是 Variational Quantum Algorithms (VQA) 中使用的损失函数 - 参数化电路关于哈密顿量 H 的期望值：$O(\\theta) = \\left\\langle00\\right| U^{\\dagger}(\\theta)HU(\\theta) \\left|00\\right\\rangle$，其中 $U(\\theta)$ 表示参数化量子电路，$\\theta = [\\theta_1, \\theta_2, \\dots, \\theta_n]$ 代表电路里的可训练参数，那么我们想要得到的是\n", + "\n", + "$$\n", + "\\nabla O(\\theta) = \\begin{bmatrix} \\frac{\\partial O}{\\partial \\theta_1} \\\\ \\frac{\\partial O}{\\partial \\theta_2}\\\\ \\vdots\\\\ \\frac{\\partial O}{\\partial \\theta_n} \\end{bmatrix}.\n", + "\\tag{1}\n", + "$$\n", + "\n", + "首先，让我们导入需要的包：" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "optical-surface", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import paddle\n", + "from paddle_quantum.circuit import UAnsatz\n", + "from paddle_quantum.utils import pauli_str_to_matrix, Hamiltonian\n", + "import warnings\n", + "warnings.filterwarnings(\"ignore\")" + ] + }, + { + "cell_type": "markdown", + "id": "apparent-violence", + "metadata": {}, + "source": [ + "接着，构造目标函数 $O(\\theta) = \\left\\langle00\\right| U^{\\dagger}(\\theta)HU(\\theta) \\left|00\\right\\rangle$ 中的哈密顿量 $H$ 和参数化量子电路 $U(\\theta)$。\n", + "\n", + "以两量子比特的电路为例，随机生成长度为 $4$ 的 Tensor 作为 $\\theta$ 构建参数化电路 $U(\\theta)$，并选择哈密顿量 $H = Z \\otimes Z$。" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "affected-progress", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "哈密顿量 H：\n", + " [[ 1.+0.j 0.+0.j 0.+0.j 0.+0.j]\n", + " [ 0.+0.j -1.+0.j 0.+0.j 0.+0.j]\n", + " [ 0.+0.j 0.+0.j -1.+0.j 0.+0.j]\n", + " [ 0.+0.j 0.+0.j 0.+0.j 1.+0.j]]\n", + "\n", + "U(theta)：\n", + "--Ry(0.389)----*----x----Ry(4.934)--\n", + " | | \n", + "--Ry(0.492)----x----*----Ry(1.200)--\n", + " \n" + ] + } + ], + "source": [ + "# 首先，定义 H 还有电路中的参数\n", + "pauli_str = [[1.0, 'Z0,Z1']]\n", + "H = Hamiltonian(pauli_str)\n", + "\n", + "# 注意：定义参数时若标明 stop_gradient=False 则为可训练的参数；如未标明，则将默认该参数为常数，将不会被内置函数计算梯度。\n", + "theta_np = np.random.uniform(0, 2 * np.pi, 4)\n", + "theta_tensor = paddle.to_tensor(theta_np, 'float64', stop_gradient=False)\n", + "\n", + "def U_theta(theta):\n", + " cir = UAnsatz(2)\n", + " cir.ry(theta[0], 0)\n", + " cir.ry(theta[1], 1)\n", + " cir.cnot([0, 1])\n", + " cir.cnot([1, 0])\n", + " cir.ry(theta[2], 0)\n", + " cir.ry(theta[3], 1)\n", + " cir.run_state_vector()\n", + " return cir\n", + "\n", + "print('哈密顿量 H：\\n', H.construct_h_matrix())\n", + "print('\\nU(theta)：')\n", + "print(U_theta(theta_tensor))" + ] + }, + { + "cell_type": "markdown", + "id": "worthy-switzerland", + "metadata": {}, + "source": [ + "## 有限差分法\n", + "\n", + "有限差分法是估算函数梯度最传统和最常用的数值方法之一。主要思想是用差分代替偏导数：\n", + "\n", + "$$\n", + "f'(x)= \\lim_{h \\to 0}\\frac{f(x+h) - f(x)}{h}.\n", + "\\tag{2}\n", + "$$\n", + "\n", + "通过选择足够小的 $h$，我们可以得到很好的导数近似值。\n", + "\n", + "以有限差分法的一种：中心差分法为例计算目标函数的梯度，我们得到\n", + "\n", + "$$\n", + "\\nabla O(\\theta) \\approx \\frac{O(\\theta+\\delta) - O(\\theta-\\delta)}{2\\delta} = \\frac{\\left\\langle00\\right| U^{\\dagger}(\\theta + \\delta)HU(\\theta + \\delta) \\left|00\\right\\rangle - \\left\\langle00\\right| U^{\\dagger}(\\theta - \\delta)HU(\\theta-\\delta) \\left|00\\right\\rangle)}{2\\delta}.\n", + "\\tag{3}\n", + "$$\n", + "\n", + "为实现上式，我们可以通过循环参数列表改变原电路中的特定参数进而能够在同一电路上反复计算目标函数，无需构建新电路或使用额外的辅助比特。\n", + "\n", + "使用 Paddle Quantum 的内置方法，我们可以构建 $U(\\theta)$ 的电路，并通过传入对应的哈密顿量 H 和 $\\delta$，轻松计算有限差分梯度。注：内置方法暂不支持指定输入态以及含噪电路。" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "hybrid-research", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--Ry(0.389)----*----x----Ry(4.934)--\n", + " | | \n", + "--Ry(0.492)----x----*----Ry(1.200)--\n", + " \n", + "目标函数的梯度为： [-0.19714755 -0.7647454 0.11976991 -0.38304339]\n" + ] + } + ], + "source": [ + "# 重复使用已定义好的 H 还有电路中的参数，注意确认定义可训练参数时已标明 stop_gradient=False\n", + "\n", + "# 构建 U(theta) 电路\n", + "cir = U_theta(theta_tensor)\n", + "print(cir)\n", + "\n", + "# 用内置差分法函数计算梯度\n", + "gradients = cir.finite_difference_gradient(H, delta=0.01)\n", + "print(\"目标函数的梯度为：\", gradients.numpy())" + ] + }, + { + "cell_type": "markdown", + "id": "continent-avatar", + "metadata": {}, + "source": [ + "## Parameter-shift 方法\n", + "\n", + "我们使用同样的目标函数 $O(\\theta) = \\left\\langle0\\right| U^{\\dagger}(\\theta)HU(\\theta) \\left|0\\right\\rangle$ 为例，将 $U(\\theta)$ 表示成 $e^{-ia\\theta G}$ 的形式，其中 $G$ 为单量子比特门且有两个不同的本征值 $\\lambda_1$ 和 $\\lambda_2$，故可以利用 $(4)$ 式 Parameter-shift 方法来计算它的梯度 [1]：\n", + "\n", + "$$\n", + "\\nabla O(\\theta) = r \\left[O(\\theta+\\frac{\\pi}{4r}) - O(\\theta-\\frac{\\pi}{4r})\\right],\n", + "\\tag{4}\n", + "$$ \n", + "\n", + "其中 $r = \\frac{a}{2} (\\lambda_2 - \\lambda_1)$。值得一提的是，我们在这里得到的是理论上精确的梯度，而不是像有限差分梯度这样的估计值。 此外，该方法不需要构建新电路或添加辅助量子比特，只需更改电路内部的参数即可进行评估。\n", + "\n", + "Paddle Quantum 提供的基础旋转门有 $R_x(\\theta)$、$R_y(\\theta)$ 和 $R_z(\\theta)$， 分别可以表示成 $e^{-i\\frac{1}{2}\\theta X}、e^{-i\\frac{1}{2}\\theta Y}、e^{-i\\frac{1}{2}\\theta Z}$。由于 $X$、$Y$ 和 $Z$ 门的本征值皆为 -1 和 1，$\\lambda_1 \\neq \\lambda_2$，因而有 $r = \\frac{1}{2}$，故这些门的梯度为 \n", + "\n", + "$$\n", + "\\frac{1}{2}[ O(\\theta + \\frac{\\pi}{2}) - O(\\theta - \\frac{\\pi}{2})].\n", + "\\tag{5}\n", + "$$\n", + "\n", + "我们将使用单比特旋转门 $R_x$ 来演示这个公式的推导。" + ] + }, + { + "cell_type": "markdown", + "id": "premium-parliament", + "metadata": {}, + "source": [ + "### 推导过程\n", + "本小节中我们将以 $R_x$ 门为例，展示公式的推导过程。\n", + "\n", + "令 $U(\\theta) = R_x(\\theta)$，有\n", + "\n", + "$$\n", + "O(\\theta) = \\left\\langle0\\right| R_x^{\\dagger}(\\theta)HR_x(\\theta) \\left|0\\right\\rangle.\n", + "\\tag{6}\n", + "$$\n", + "\n", + "因为 $R_x(\\theta) = e^{-i\\frac{1}{2}\\theta X}$，其中 $X$ 代表泡利 $X$ 门，则 $\\frac{\\partial}{\\partial \\theta} R_x(\\theta) =-i\\frac{1}{2}Xe^{-i\\frac{\\theta}{2}X}=-i\\frac{1}{2}XR_x(\\theta)$。利用乘积法则，目标函数的导数可以被写成\n", + "\n", + "$$\n", + "O'(\\theta) = \\left\\langle0\\right| [\\frac{i}{2}X] R_x^{\\dagger}(\\theta)HR_x(\\theta)\\left|0\\right\\rangle + \\left\\langle0\\right| R_x^{\\dagger}(\\theta)H [-\\frac{i}{2}X] R_x(\\theta)\\left|0\\right\\rangle.\n", + "\\tag{7}\n", + "$$\n", + "\n", + "为了之后重新简化这部分公式，我们提出来一个 $r$ 放到最前面（对于 $R_x$ 门，$r$ 为 $\\frac{1}{2}$），我们得到：\n", + "\n", + "$$\n", + "O'(\\theta) = r \\left\\langle0\\right| [\\frac{i}{2r}X] R_x^{\\dagger}(\\theta)HR_x(\\theta)\\left|0\\right\\rangle + \\left\\langle0\\right| R_x^{\\dagger}(\\theta)H [-\\frac{i}{2r}X] R_x(\\theta)\\left|0\\right\\rangle.\n", + "\\tag{8}\n", + "$$\n", + "\n", + "由于对任意算符 $U$、$V$ 和 $Q$ 以及任意量子态 $|\\psi\\rangle$，\n", + "\n", + "$$\n", + "\\langle\\psi|U^\\dagger QV|\\psi\\rangle + \\langle\\psi|V^\\dagger QU|\\psi\\rangle = \\frac{1}{2} \\big(\\langle\\psi|(U+V)^\\dagger Q(U+V)|\\psi\\rangle - \\langle\\psi|(U-V)^\\dagger Q(U-V)|\\psi\\rangle \\big),\n", + "\\tag{9}\n", + "$$\n", + "\n", + "那么 \n", + "\n", + "$$\n", + "O'(\\theta) = \\frac{r}{2} \\big( \\left\\langle0\\right|R_x^{\\dagger}(\\theta) [I + \\frac{i}{2r}X]H[I - \\frac{i}{2r}X]R_x(\\theta)\\left|0\\right\\rangle - \\left\\langle0\\right| R_x^{\\dagger}(\\theta) [I - \\frac{i}{2r}X] H [I+\\frac{i}{2r}X] R_x(\\theta)\\left|0\\right\\rangle \\big).\n", + "\\tag{10}\n", + "$$\n", + "\n", + "由欧拉公式，且因为 $𝐺$ 有两个不同的本征值，我们可以把 $U(\\theta)$ 写做 $e^{-ia\\theta G} = Icos(r\\theta) - i\\frac{a}{r}Gsin(r\\theta)$，则 $R_x(\\theta) = Icos(r\\theta) - i\\frac{1}{2r}Xsin(r\\theta)$ [1]，我们发现\n", + "\n", + "$$\n", + "R_x(\\frac{\\pi}{4r}) = I\\cos(\\frac{\\pi}{4}) - i\\frac{1}{2r}X\\sin(\\frac{\\pi}{4}) = \\frac{1}{\\sqrt2}(I-\\frac{i}{2r}X).\n", + "\\tag{11}\n", + "$$\n", + "\n", + "我们可以用同样的方法得到\n", + "\n", + "$$\n", + "R_x(-\\frac{\\pi}{4r}) = \\frac{1}{\\sqrt2}(I+\\frac{i}{2r}X).\n", + "\\tag{12}\n", + "$$\n", + "\n", + "因此，公式可以简化为\n", + "\n", + "$$\n", + "O'(\\theta) = r\\big[ \\left\\langle0\\right|R_x^{\\dagger}(\\theta+\\frac{\\pi}{4r})HR_x(\\theta+\\frac{\\pi}{4r})\\left|0\\right\\rangle - \\left\\langle0\\right| R_x^{\\dagger}(\\theta-\\frac{\\pi}{4r}) H R_x(\\theta-\\frac{\\pi}{4r})\\left|0\\right\\rangle \\big],\n", + "\\tag{13}\n", + "$$\n", + "\n", + "并得到最终公式\n", + "\n", + "$$\n", + "O'(\\theta) = r\\big[O(\\theta+\\frac{\\pi}{4r}) - O(\\theta-\\frac{\\pi}{4r}))\\big] = \\frac{1}{2}\\big[ O(\\theta + \\frac{\\pi}{2}) - O(\\theta - \\frac{\\pi}{2})\\big].\n", + "\\tag{14}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "id": "loaded-miami", + "metadata": {}, + "source": [ + "### Paddle Quantum 实现\n", + "我们可以通过 Paddle Quantum 的内置函数，用 Parameter-shift 方法计算电路的梯度。注：内置方法暂不支持指定输入态以及含噪电路。" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "conscious-namibia", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--Ry(0.389)----*----x----Ry(4.934)--\n", + " | | \n", + "--Ry(0.492)----x----*----Ry(1.200)--\n", + " \n", + "目标函数的梯度为： [-0.19714837 -0.76474861 0.11977042 -0.38304499]\n" + ] + } + ], + "source": [ + "# 重复使用已定义好的 H 还有电路中的参数，注意确认定义可训练参数时已标明 stop_gradient=False\n", + "\n", + "# 构建含参电路\n", + "cir = U_theta(theta_tensor)\n", + "print(cir)\n", + "\n", + "gradients = cir.param_shift_gradient(H)\n", + "print(\"目标函数的梯度为：\", gradients.numpy())" + ] + }, + { + "cell_type": "markdown", + "id": "frank-disaster", + "metadata": {}, + "source": [ + "## Linear Combination of Unitary Gradients 方法\n", + "\n", + "使用 Paddle Quantum 构建参数化电路 $U(\\theta)$ 需要许多参数化的单量子比特和双量子比特旋转门如 $R_x$ 和 $CR_x$，因此我们可以将 $U(\\theta)$ 重写为 $U_{1}(\\theta_1)U_{2}(\\theta_2)\\cdots U_{m}(\\theta_m)$，其中 $U_i(\\theta_i)$ 是单量子比特或双量子比特门，$m$ 则是该电路 $U(\\theta)$ 中参数化门的数量。对 $\\theta$ 求导，我们有 $\\frac{\\partial U(\\theta)}{\\partial \\theta_i}=U_{1}(\\theta_1)U_{2}(\\theta_2)\\cdots\\frac{\\partial U_i{(\\theta_i)}}{\\partial \\theta_i}\\cdots U_{m}(\\theta_m)$。只要我们知道所有参数化门的 $\\frac{\\partial U_i{(\\theta_i)}}{\\partial \\theta_i}$，我们就可以很容易地得到所有参数的梯度 [2]。接下来我们介绍如何利用 Paddle Quantum 构造单量子比特门和双量子比特门梯度的电路。" + ] + }, + { + "cell_type": "markdown", + "id": "comparable-celebrity", + "metadata": {}, + "source": [ + "### 单量子比特门梯度\n", + "\n", + "让我们首先考虑单量子比特门。同样以 $R_x(\\theta)$ 为例，在前面的部分中，我们已经证明了 $\\frac{\\partial R_x(\\theta)}{\\partial \\theta}=-i\\frac{1}{2}XR_x(\\theta)$，这很容易使用电路构建。让我们尝试使用 Paddle Quantum 来实现它。" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "israeli-globe", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "原电路：\n", + "--Rx(1.047)--\n", + " \n", + "用于计算 Rx 梯度的电路：\n", + "------------x----Rx(1.047)--\n", + " | \n", + "--H---SDG---*--------H------\n", + " \n" + ] + } + ], + "source": [ + "# 构建只带一个单量子比特门 Rx 的电路\n", + "theta = paddle.to_tensor(np.pi / 3, 'float64')\n", + "cir = UAnsatz(1)\n", + "cir.rx(theta, 0)\n", + "print('原电路：')\n", + "print(cir)\n", + "\n", + "print('用于计算 Rx 梯度的电路：')\n", + "# 这里的第一个参数是门的索引，第二个参数是门的名称\n", + "print(cir.pauli_rotation_gate_partial(0, 'rx'))" + ] + }, + { + "cell_type": "markdown", + "id": "upper-soviet", + "metadata": {}, + "source": [ + "对 $u3(\\theta, \\phi, \\lambda)$ 门做同样的事情要复杂得多，不过我们提供了内置方法来生成 Paddle Quantum 中所有参数化单量子比特门，即 $R_x$、$R_y$、$R_z$ 和 $u3$ 门，用于计算梯度所需的电路。" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "organizational-finger", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "原电路：\n", + "--U--\n", + " \n", + "用于计算 u3 梯度的电路：\n", + "------------z----U--\n", + " | \n", + "--H---SDG---*----H--\n", + " \n", + "--Rz(5.378)---------y----Ry(6.122)----Rz(3.188)--\n", + " | \n", + "------H-------SDG---*--------H-------------------\n", + " \n", + "--Rz(5.378)----Ry(6.122)----z----Rz(3.188)--\n", + " | \n", + "------H-----------SDG-------*--------H------\n", + " \n" + ] + } + ], + "source": [ + "cir = UAnsatz(1)\n", + "theta = paddle.uniform([3], min=0.0, max=2*np.pi, dtype='float64')\n", + "cir.u3(theta[0], theta[1], theta[2], 0)\n", + "print('原电路：')\n", + "print(cir)\n", + "\n", + "print('用于计算 u3 梯度的电路：')\n", + "# 由于 u3 门含有3个参数，我们总共需要3个电路来计算 u3 门的梯度。\n", + "# 括号里的第一个参数是门的索引，第二个参数是所用可训练参数的索引\n", + "print(cir.u3_partial(0, 0))\n", + "print(cir.u3_partial(0, 1))\n", + "print(cir.u3_partial(0, 2))" + ] + }, + { + "cell_type": "markdown", + "id": "specific-minutes", + "metadata": {}, + "source": [ + "### 双量子比特门梯度\n", + "\n", + "Paddle Quantum 也提供了许多双量子比特参数化门。它们可以被分为两种类型：一种是像 $CR_x$ 这样的控制旋转门，另一种是像 $R_{xx}$ 这样的双量子比特旋转门。双量子比特旋转门的梯度电路很容易构建。我们以𝑅𝑥𝑥为例，遵循单量子比特旋转门的思想，我们首先将其写成 $R_{xx}(\\theta)=e^{-i\\frac{\\theta}{2}X\\otimes X}$，然后得到可以被转换为电路的公式：$\\frac{\\partial R_{xx}(\\theta)}{\\partial \\theta}=-i\\frac{1}{2}X\\otimes Xe^{-i\\frac{\\theta}{2}X\\otimes X}$。" + ] + }, + { + "cell_type": "markdown", + "id": "empirical-black", + "metadata": {}, + "source": [ + "我们在计算控制旋转门的梯度时需要小心。通常来说，我们需要两个电路来计算含一个参数的控制旋转门的梯度，例如 $CR_x(\\theta)$。\n", + "\n", + "$CR_x(\\theta)$ 可以被写成 $\\left|0\\right>\\left<0\\right|\\otimes I + \\left|1\\right>\\left<1\\right|\\otimes R_x(\\theta)$，所以它的梯度为：\n", + "\n", + "$$\n", + "\\frac{\\partial CR_x(\\theta)}{\\partial \\theta}=\\left|1\\right>\\left<1\\right|\\otimes \\frac{\\partial R_x(\\theta)}{\\partial \\theta}=-\\frac{i}{2}\\left|1\\right>\\left<1\\right|\\otimes Xe^{-i\\frac{\\theta}{2}X}.\n", + "\\tag{15}\n", + "$$\n", + "\n", + "然而，这个方程不能用一个电路直接表示。我们需要在这里使用一个小“技巧”，我们不直接使用这个公式，而是将其分解为两个项：\n", + "\n", + "$$\n", + "\\frac{\\partial CR_x(\\theta)}{\\partial \\theta}=-\\frac{i}{4}(\\left|0\\right>\\left<0\\right|\\otimes I + \\left|1\\right>\\left<1\\right|\\otimes R_x(\\theta))I\\otimes X + \\frac{i}{4}(\\left|0\\right>\\left<0\\right|\\otimes I + \\left|1\\right>\\left<1\\right|\\otimes R_x(\\theta))Z\\otimes X.\n", + "\\tag{16}\n", + "$$ \n", + "\n", + "你可以验证此公式是否与前一个公式等效。通过这种做法，我们可以使用两个电路来计算 $CR_x$ 的梯度。" + ] + }, + { + "cell_type": "markdown", + "id": "lesser-evanescence", + "metadata": {}, + "source": [ + "同样，我们提供了内置方法来生成 Paddle Quantum 中所有参数化双量子比特门，即 $R_{xx}$、$R_{yy}$、$R_{zz}$、$CR_x$、$CR_y$、$CR_z$ 和 $CU$ 门，用于计算梯度所需的电路。" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "promising-arnold", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "原电路：\n", + "--*----Rzz(4.42)--------*------\n", + " | | | \n", + "--U----Rzz(4.42)----Ry(4.082)--\n", + " \n", + "用于计算 rzz 门梯度的电路：\n", + "--*---------z---------Rzz(4.42)--------*------\n", + " | | | | \n", + "--U---------|----z----Rzz(4.42)----Ry(4.082)--\n", + " | | \n", + "--H---SDG---*----*--------H-------------------\n", + " \n", + "用于计算 cry 门梯度的电路：\n", + "--*----Rzz(4.42)----y--------*------\n", + " | | | | \n", + "--U----Rzz(4.42)----|----Ry(4.082)--\n", + " | \n", + "--H-------SDG-------*--------H------\n", + " \n", + "--*----Rzz(4.42)---------y--------*------\n", + " | | | | \n", + "--U----Rzz(4.42)----z----|----Ry(4.082)--\n", + " | | \n", + "--H--------S--------*----*--------H------\n", + " \n" + ] + } + ], + "source": [ + "theta = paddle.uniform([5], min=0.0, max=2*np.pi, dtype='float64')\n", + "cir = UAnsatz(2)\n", + "cir.cu(theta[0], theta[1], theta[2], [0, 1])\n", + "cir.rzz(theta[3], [0, 1])\n", + "cir.cry(theta[4], [0, 1])\n", + "print('原电路：')\n", + "print(cir)\n", + "\n", + "# 括号里的第一个参数是门的索引，第二个参数是所用可训练参数的索引\n", + "# 由于 cu 门含有三个参数，每个参数需要两个电路，所以我们总共有6个电路。\n", + "# 用于计算 cu 门梯度的电路：\n", + "cu3_00 = cir.cu3_partial(0, 0)[0]\n", + "cu3_01 = cir.cu3_partial(0, 0)[1]\n", + "cu3_10 = cir.cu3_partial(0, 1)[0]\n", + "cu3_11 = cir.cu3_partial(0, 1)[1]\n", + "cu3_20 = cir.cu3_partial(0, 2)[0]\n", + "cu3_21 = cir.cu3_partial(0, 2)[1]\n", + "\n", + "# 这里的第一个参数是门的索引，第二个参数是门的名称\n", + "print('用于计算 rzz 门梯度的电路：')\n", + "print(cir.pauli_rotation_gate_partial(1, 'RZZ_gate'))\n", + "\n", + "# 这里的第一个参数是门的索引，第二个参数是门的名称\n", + "print('用于计算 cry 门梯度的电路：')\n", + "print(cir.control_rotation_gate_partial(2, 'cry')[0])\n", + "print(cir.control_rotation_gate_partial(2, 'cry')[1])" + ] + }, + { + "cell_type": "markdown", + "id": "outer-family", + "metadata": {}, + "source": [ + "现在我们已经为计算梯度准备了所有单独的电路，下一步是计算梯度的精确值。怎么做？我们需要将这些电路传入我们的目标函数中，结果就是我们想要的梯度。而对于像 $CR_x$ 这样的门，我们要将两个电路结果的平均值作为梯度。我们还提供了一个用 Linear Combination 计算参数化电路梯度的内置方法（注：内置方法暂不支持指定输入态以及含噪电路）：" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "viral-duncan", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--U----*----x----Ry(4.182)--\n", + " | | \n", + "--U----x----*----Ry(1.693)--\n", + " \n", + "目标函数的梯度为： [ 5.55111512e-17 -7.96572821e-02 -6.20103361e-02 5.55111512e-17\n", + " 1.91859815e-01 -3.15824394e-01 4.24351014e-01 -5.25105122e-01]\n" + ] + } + ], + "source": [ + "# 为我们的电路随机生成参数\n", + "theta = paddle.uniform(shape=[8], dtype='float64', min=0.0, max=np.pi * 2)\n", + "theta.stop_gradient = False\n", + "\n", + "# 构建 U(theta) 电路\n", + "cir = UAnsatz(2)\n", + "cir.complex_entangled_layer(theta[:6], 1)\n", + "cir.ry(theta=theta[6], which_qubit=0)\n", + "cir.ry(theta=theta[7], which_qubit=1)\n", + "cir.run_state_vector()\n", + "print(cir)\n", + "\n", + "# 使用我们的内置方法计算梯度\n", + "# 我们传入目标函数中使用的哈密顿量 H\n", + "gradient = cir.linear_combinations_gradient(H, shots=0)\n", + "print(\"目标函数的梯度为：\", gradient.numpy())" + ] + }, + { + "cell_type": "markdown", + "id": "documented-shooting", + "metadata": {}, + "source": [ + "## 应用： Paddle Quantum 模拟变分量子本征求解器（VQE）\n", + "\n", + "变分量子本征求解器（variational quantum eigensolver, VQE）[3] 可以用变分量子电路来计算某个给定哈密顿量的基态能量，关于其具体的原理和背景在之前的教程 [变分量子本征求解器](../quantum_simulation/VQE_CN.ipynb) 中有详细的讲解，感兴趣的读者可以前往阅读。\n", + "\n", + "在这里，我们尝试用一个简单的 VQE 电路来求解氢分子 $H_2$ 的哈密顿量的基态能量。在这个过程中，我们将使用上面介绍的 Parameter-shift 方法来计算梯度。" + ] + }, + { + "cell_type": "markdown", + "id": "joined-frontier", + "metadata": {}, + "source": [ + "### 使用 Paddle 的优化器\n", + "\n", + "首先，我们将使用 Paddle 的优化器 Adam 来运行我们的示例。我们可以选择有限差分法或 Parameter-shift 作为计算梯度的方法。" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "short-script", + "metadata": {}, + "outputs": [], + "source": [ + "from paddle_quantum.VQE.chemistrysub import H2_generator\n", + "from paddle_quantum.expecval import ExpecVal\n", + "\n", + "# 生成哈密顿量\n", + "pauli_str, N = H2_generator()\n", + "H = Hamiltonian(pauli_str)\n", + "\n", + "# 超参数设置\n", + "ITR = 80 # 设置训练的总迭代次数\n", + "LR = 0.4 # 设置学习速率\n", + "D = 2 # 设置量子神经网络中重复计算模块的深度 Depth\n", + "\n", + "def U_theta(theta, Hamiltonian, N, D):\n", + " \"\"\"\n", + " Quantum Neural Network\n", + " \"\"\"\n", + " # 按照量子比特数量/网络宽度初始化量子神经网络\n", + " cir = UAnsatz(N)\n", + "\n", + " # 内置的 {R_y + CNOT} 电路模板\n", + " theta = paddle.reshape(theta, [D+1, N, 1])\n", + " cir.real_entangled_layer(theta[:D], D)\n", + "\n", + " # 铺上最后一列 R_y 旋转门\n", + " for i in range(N):\n", + " cir.ry(theta=theta[D][i][0], which_qubit=i)\n", + "\n", + " # 量子神经网络作用在默认的初始态 |0...0> 上\n", + " cir.run_state_vector()\n", + " \n", + " return cir" + ] + }, + { + "cell_type": "markdown", + "id": "extraordinary-northern", + "metadata": {}, + "source": [ + "在前向传播机制中，我们使用 Parameter-shift 方法得到梯度，并计算期望值。如果你想使用有限差分方法进行尝试，可以将传入 Expecval 中的方法更改为 'finite_diff'。" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "worse-waters", + "metadata": {}, + "outputs": [], + "source": [ + "class StateNet(paddle.nn.Layer):\n", + "\n", + " def __init__(self, cir):\n", + " super(StateNet, self).__init__()\n", + " \n", + " self.cir = cir\n", + " params = cir.get_param()\n", + " \n", + " # 用电路里的参数初始化 theta 参数列表\n", + " self.theta = self.create_parameter(shape=[len(params)], \n", + " default_initializer=paddle.nn.initializer.Assign(params),\n", + " dtype='float32', is_bias=False)\n", + " \n", + " # 定义损失函数和前向传播机制\n", + " def forward(self):\n", + " # 用 Parameter-shift 梯度计算损失函数/期望值\n", + " loss = ExpecVal.apply(self.cir, self.theta.cast('float64'), 'param_shift', H, shots=0)\n", + " \n", + " return loss, self.cir" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "informative-sword", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "iter: 20 loss: -1.0855\n", + "iter: 20 Ground state energy: -1.0855 Ha\n", + "iter: 40 loss: -1.1286\n", + "iter: 40 Ground state energy: -1.1286 Ha\n", + "iter: 60 loss: -1.1356\n", + "iter: 60 Ground state energy: -1.1356 Ha\n", + "iter: 80 loss: -1.1361\n", + "iter: 80 Ground state energy: -1.1361 Ha\n", + "\n", + "训练后的电路：\n", + "--Ry(1.554)----*--------------x----Ry(1.567)----*--------------x----Ry(3.153)--\n", + " | | | | \n", + "--Ry(4.700)----x----*---------|----Ry(4.705)----x----*---------|----Ry(1.506)--\n", + " | | | | \n", + "--Ry(3.084)---------x----*----|----Ry(1.785)---------x----*----|----Ry(1.550)--\n", + " | | | | \n", + "--Ry(3.124)--------------x----*----Ry(1.576)--------------x----*----Ry(6.263)--\n", + " \n", + "\n", + "电路计算得到的基态能量是: [-1.13611258] Ha\n", + "真实的基态能量为: -1.13618 Ha\n" + ] + } + ], + "source": [ + "# 初始化电路中的 theta 参数列表，并用 [0, 2*pi] 的均匀分布来填充初始值\n", + "theta = paddle.to_tensor(np.random.uniform(0.0, 2*np.pi, (D+1) * N), stop_gradient=False)\n", + "\n", + "# 创建电路\n", + "cir = U_theta(theta, H, N, D)\n", + "\n", + "# 确定网络的参数维度\n", + "net = StateNet(cir)\n", + "\n", + "# 一般来说，我们利用 Adam 优化器来获得相对好的收敛，\n", + "# 当然你可以改成 SGD 或者是 RMS prop.\n", + "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters())\n", + "\n", + "# 记录优化结果\n", + "summary_iter, summary_loss = [], []\n", + "\n", + "# 优化循环\n", + "for itr in range(1, ITR + 1):\n", + "\n", + " # 前向传播计算损失函数\n", + " loss, cir = net()\n", + "\n", + " # 在动态图机制下，反向传播极小化损失函数\n", + " loss.backward()\n", + " opt.minimize(loss)\n", + " opt.clear_grad()\n", + "\n", + " # 更新优化结果\n", + " summary_loss.append(loss.numpy())\n", + " summary_iter.append(itr)\n", + "\n", + " # 打印结果\n", + " if itr % 20 == 0:\n", + " print(\"iter:\", itr, \"loss:\", \"%.4f\" % loss.numpy())\n", + " print(\"iter:\", itr, \"Ground state energy:\", \"%.4f Ha\" \n", + " % loss.numpy())\n", + " if itr == ITR:\n", + " print(\"\\n训练后的电路：\") \n", + " print(cir)\n", + "\n", + "print('\\n电路计算得到的基态能量是: ', summary_loss[-1], \"Ha\")\n", + "print('真实的基态能量为: ', -1.13618, \"Ha\")" + ] + }, + { + "cell_type": "markdown", + "id": "normal-graham", + "metadata": {}, + "source": [ + "我们可以看到我们得到的基态能量接近理论值。" + ] + }, + { + "cell_type": "markdown", + "id": "exclusive-television", + "metadata": {}, + "source": [ + "### 使用 SciPy 的优化器\n", + "\n", + "我们还将演示如何在 Paddle Quantum 里使用 SciPy 的优化器实现 VQE。对于这个例子，我们将使用共轭梯度法 (CG) 优化器和 Linear\n", + "Combination 方法来求解我们哈密顿量的基态能量。\n", + "\n", + "此外，我们还支持使用 Newton-CG、Powell 和 SLSQP 方法的 SciPy 优化器。" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "august-czech", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss: [-0.32223041]\n", + "loss: [-0.41429542]\n", + "loss: [-0.47219271]\n", + "loss: [-0.58479231]\n", + "loss: [-0.70924513]\n", + "loss: [-0.88441433]\n", + "loss: [-0.97408026]\n", + "loss: [-1.09436626]\n", + "loss: [-1.10973582]\n", + "loss: [-1.11870276]\n", + "loss: [-1.11946487]\n", + "loss: [-1.11967869]\n", + "loss: [-1.1200893]\n", + "loss: [-1.12525337]\n", + "loss: [-1.12765788]\n", + "loss: [-1.13375079]\n", + "loss: [-1.13480047]\n", + "loss: [-1.1358785]\n", + "loss: [-1.13605957]\n", + "loss: [-1.13608542]\n", + "loss: [-1.1361108]\n", + "loss: [-1.13616537]\n", + "loss: [-1.1361784]\n", + "loss: [-1.13618041]\n", + "loss: [-1.13618262]\n", + "loss: [-1.13618313]\n", + "loss: [-1.1361833]\n", + "loss: [-1.13618356]\n", + "loss: [-1.13618403]\n", + "loss: [-1.13618415]\n", + "loss: [-1.13618419]\n", + "loss: [-1.13618435]\n", + "loss: [-1.13618448]\n", + "loss: [-1.13618456]\n", + "loss: [-1.13618468]\n", + "loss: [-1.13618483]\n", + "loss: [-1.13618528]\n", + "loss: [-1.13618545]\n", + "loss: [-1.13618565]\n", + "loss: [-1.13618618]\n", + "loss: [-1.13618656]\n", + "loss: [-1.13618694]\n", + "loss: [-1.13618745]\n", + "loss: [-1.13618776]\n", + "loss: [-1.13618788]\n", + "loss: [-1.13618801]\n", + "loss: [-1.13618838]\n", + "loss: [-1.13618865]\n", + "loss: [-1.13618885]\n", + "loss: [-1.13618901]\n", + "loss: [-1.13618907]\n", + "loss: [-1.13618909]\n", + "loss: [-1.13618909]\n", + "loss: [-1.13618911]\n", + "loss: [-1.13618911]\n", + "loss: [-1.13618911]\n", + "loss: [-1.13618912]\n", + "loss: [-1.13618912]\n", + "loss: [-1.13618913]\n", + "loss: [-1.13618915]\n", + "loss: [-1.13618918]\n", + "loss: [-1.13618922]\n", + "loss: [-1.13618925]\n", + "loss: [-1.13618926]\n", + "loss: [-1.13618933]\n", + "loss: [-1.1361894]\n", + "loss: [-1.13618941]\n", + "loss: [-1.13618941]\n", + "loss: [-1.13618942]\n", + "loss: [-1.13618943]\n", + "loss: [-1.13618943]\n", + "loss: [-1.13618943]\n", + "Optimization terminated successfully.\n", + "真实的基态能量为: -1.13618 Ha\n" + ] + } + ], + "source": [ + "from paddle_quantum.optimizer import ConjugateGradient\n", + "\n", + "# 创建电路\n", + "cir = U_theta(theta, H, N, D)\n", + "\n", + "optimizer = ConjugateGradient(cir, H, shots=0, grad_func_name='linear_comb')\n", + "optimizer.minimize(iterations=80)\n", + "print('真实的基态能量为: ', -1.13618, \"Ha\")" + ] + }, + { + "cell_type": "markdown", + "id": "hairy-mining", + "metadata": {}, + "source": [ + "## 总结\n", + "\n", + "本教程介绍的三种计算参数化量子电路梯度的方法中，可以看到有限差分方法和 Parameter-shift 方法具有相似的形式：它们都需要对每个参数进行两次函数评估。这些方法的好处是可以在不了解电路或目标函数的情况下计算梯度。我们可以将它们视为一个黑匣子，只需输入不同的参数即可获得梯度。我们在这两者之间的首选是 Parameter-shift 方法，因为它的结果是一个解析梯度，而有限差分方法只能得到梯度的估算值。但是，Parameter-shift 仅适用于可以由具有两个不同本征值的 $G$ 生成的 $U(\\theta)$：$U(\\theta) = e^{-ia\\theta G}$，或适用于可以被分解变成这种形式的门的乘积的 $U(\\theta)$。\n", + "\n", + "使用 Linear Combination 方法来计算给定电路的梯度可能是最直接的方法。我们可以在数学形式下对酉门求微分，并使用电路来表示结果公式。与其他两种方法一样，这种方法所需的电路数量与原始电路中的参数数量成正比。我们甚至可以为简单的门（如 $R_x、R_{xx}$ 等）构建一个单独的电路来计算梯度。但是，请注意，我们在此方法中会使用辅助量子比特。此外，你可能已经注意到，这种方法在复杂的电路上需要运行很长时间。这是因为随着量子比特数量的增加，用于表示多量子比特门一阶微分的电路数量也会增加。" + ] + }, + { + "cell_type": "markdown", + "id": "adjusted-royalty", + "metadata": {}, + "source": [ + "_______\n", + "\n", + "## 参考文献\n", + "\n", + "[1] Crooks, Gavin E. \"Gradients of parameterized quantum gates using the parameter-shift rule and gate decomposition.\" [arXiv preprint arXiv:1905.13311 (2019)](https://arxiv.org/abs/1905.13311).\n", + "\n", + "[2] Somma, Rolando, et al. \"Simulating physical phenomena by quantum networks.\" [Physical Review A 65.4 (2002): 042323](https://arxiv.org/abs/quant-ph/0108146).\n", + "\n", + "[3] Peruzzo, Alberto, et al. \"A variational eigenvalue solver on a photonic quantum processor.\" [Nature communications 5.1 (2014): 1-7](https://www.nature.com/articles/ncomms5213).\n", + "\n", + "[4] Schuld, Maria, et al. \"Evaluating analytic gradients on quantum hardware.\" [Physical Review A 99.3 (2019): 032331](https://arxiv.org/abs/1811.11184)." + ] + } + ], + "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.7.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tutorial/qnn_research/Gradient_EN.ipynb b/tutorial/qnn_research/Gradient_EN.ipynb new file mode 100644 index 0000000..b4b02ef --- /dev/null +++ b/tutorial/qnn_research/Gradient_EN.ipynb @@ -0,0 +1,861 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "e8062c41", + "metadata": {}, + "source": [ + "# Calculating Gradient Using Quantum Circuit\n", + "\n", + " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " + ] + }, + { + "cell_type": "markdown", + "id": "d8947f99", + "metadata": {}, + "source": [ + "## Overview\n", + "\n", + "When using variational quantum algorithms like [Variational Quantum Eigensolver (VQE)](../quantum_simulation/VQE_EN.ipynb) and [Quantum Approximate Optimization Algorithm (QAOA)](../combinatorial_optimization/QAOA_EN.ipynb), which involves varying parameters of quantum circuit to minimize an objective function of interest, it brings out an important question - what are the ways to calculate the gradient of a parameterized quantum circuit? Since the objective function is being evaluated using a quantum circuit, it's necessary to evaluate its gradient using quantum algorithms as well. Compared with computing gradient classically, this is more challenging for sure. Below we provide three different methods to accomplish this task on a quantum computer. And here we demonstrate the code and simulate their effect of running on a quantum computer using Paddle Quantum." + ] + }, + { + "cell_type": "markdown", + "id": "61395a57", + "metadata": {}, + "source": [ + "## Introduction\n", + "\n", + "Suppose the objective function is the typical parameterized cost function used in VQA: $O(\\theta) = \\left\\langle00\\right| U^{\\dagger}(\\theta)HU(\\theta) \\left|00\\right\\rangle$ where H is a Hamiltonian, $U(\\theta)$ represents the parameterized quantum circuit and $\\theta = [\\theta_1, \\theta_2, \\dots, \\theta_n]$ is a list of trainable parameters in the circuit, then our goal is to find\n", + "\n", + "$$\n", + "\\nabla O(\\theta) = \\begin{bmatrix} \\frac{\\partial O}{\\partial \\theta_1} \\\\ \\frac{\\partial O}{\\partial \\theta_2}\\\\ \\vdots\\\\ \\frac{\\partial O}{\\partial \\theta_n} \\end{bmatrix}.\n", + "\\tag{1}\n", + "$$\n", + "\n", + "First, let's import all the required packages." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "5e438617", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import paddle\n", + "from paddle_quantum.circuit import UAnsatz\n", + "from paddle_quantum.utils import pauli_str_to_matrix, Hamiltonian\n", + "import warnings\n", + "warnings.filterwarnings(\"ignore\")" + ] + }, + { + "cell_type": "markdown", + "id": "ec29c111", + "metadata": {}, + "source": [ + "Then, let's construct our $U(\\theta)$ and Hamiltonian $H$ of the objective function $O(\\theta) = \\left\\langle00\\right| U^{\\dagger}(\\theta)HU(\\theta) \\left|00\\right\\rangle$.\n", + "\n", + "We will demonstrate our example on a 2-qubit quantum circuit, constructing $U(\\theta)$ with randomly generated theta of size four. We choose our Hamiltonian H to be $H = Z \\otimes Z$." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "00c29cb2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hamiltonian H: \n", + " [[ 1.+0.j 0.+0.j 0.+0.j 0.+0.j]\n", + " [ 0.+0.j -1.+0.j 0.+0.j 0.+0.j]\n", + " [ 0.+0.j 0.+0.j -1.+0.j 0.+0.j]\n", + " [ 0.+0.j 0.+0.j 0.+0.j 1.+0.j]]\n", + "\n", + "U(theta):\n", + "--Ry(5.690)----*----x----Ry(3.107)--\n", + " | | \n", + "--Ry(2.521)----x----*----Ry(0.437)--\n", + " \n" + ] + } + ], + "source": [ + "# Define Hamiltonian H\n", + "pauli_str = [[1.0, 'Z0,Z1']]\n", + "H = Hamiltonian(pauli_str)\n", + "\n", + "# Randomly generate parameters in range from 0 to 2*PI\n", + "theta_np = np.random.uniform(0, 2 * np.pi, 4)\n", + "# Warning: Note that when defining theta, if we mark stop_gradient=False, then this parameter is trainable; \n", + "# otherwise, the parameter will be treated as constant, its gradient will not be calculated and it will not be updated in training process.\n", + "theta_tensor = paddle.to_tensor(theta_np, 'float64', stop_gradient=False)\n", + "\n", + "def U_theta(theta):\n", + " cir = UAnsatz(2)\n", + " cir.ry(theta[0], 0)\n", + " cir.ry(theta[1], 1)\n", + " cir.cnot([0, 1])\n", + " cir.cnot([1, 0])\n", + " cir.ry(theta[2], 0)\n", + " cir.ry(theta[3], 1)\n", + " cir.run_state_vector()\n", + " return cir\n", + "\n", + "print('Hamiltonian H: \\n', H.construct_h_matrix())\n", + "print('\\nU(theta):')\n", + "print(U_theta(theta_tensor))" + ] + }, + { + "cell_type": "markdown", + "id": "fc5028f6", + "metadata": {}, + "source": [ + "## Finite Difference Method\n", + "\n", + "The Finite difference method is one of the most traditional and common numerical methods to estimate the gradient of a function. The main idea is that the error of the derivative of a function $f(x)$ tends to zero as $h$ tends to zero: \n", + "\n", + "$$\n", + "f'(x)= \\lim_{h \\to 0}\\frac{f(x+h) - f(x)}{h}.\n", + "\\tag{2}\n", + "$$\n", + "\n", + "By choosing a sufficiently small $h$, we can get a good approximation of the derivative.\n", + "\n", + "For example, by using one type of finite difference, the central finite difference method, the objective function's gradient will be\n", + "\n", + "$$\n", + "\\nabla O(\\theta) \\approx \\frac{O(\\theta+\\delta) - O(\\theta-\\delta)}{2\\delta} = \\frac{\\left\\langle00\\right| U^{\\dagger}(\\theta + \\delta)HU(\\theta + \\delta) \\left|00\\right\\rangle - \\left\\langle00\\right| U^{\\dagger}(\\theta - \\delta)HU(\\theta-\\delta) \\left|00\\right\\rangle)}{2\\delta}.\n", + "\\tag{3}\n", + "$$\n", + "\n", + "When implementing this, we can simply loop through the parameter list, shift the specific parameter in the original circuit and evaluate the objective function over and over again. There's no need to build extra circuits or using extra qubits.\n", + "\n", + "Using Paddle Quantum's built-in method, we can build the circuit of $U(\\theta)$, and compute the finite-difference gradient easily by passing in the corresponding Hamiltonian H and the delta. Note: The built-in method currently does not support assigning an input state or running on a noisy circuit." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "c836f71e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--Ry(5.690)----*----x----Ry(3.107)--\n", + " | | \n", + "--Ry(2.521)----x----*----Ry(0.437)--\n", + " \n", + "Gradient of this objective function is: [-0.79156126 0.12584221 -0.26541629 0.78068313]\n" + ] + } + ], + "source": [ + "# We reuse the predefined Hamiltonian H and parameters of the circuit. \n", + "# Again, be sure to mark stop_gradient=False when defining tensor for parameters of the circuit\n", + "\n", + "# Constructing circuit U(theta)\n", + "cir = U_theta(theta_tensor)\n", + "print(cir)\n", + "\n", + "# Calculating finite-difference gradient\n", + "gradients = cir.finite_difference_gradient(H, delta=0.01)\n", + "print(\"Gradient of this objective function is: \", gradients.numpy())" + ] + }, + { + "cell_type": "markdown", + "id": "8055ed76", + "metadata": {}, + "source": [ + "## Parameter-shift Method\n", + "Again, we use this objective function $O(\\theta) = \\left\\langle0\\right| U^{\\dagger}(\\theta)HU(\\theta) \\left|0\\right\\rangle$ as our example. If $U(\\theta)$ can be written as $e^{-ia\\theta G}$ where $G$ has two unique eigenvalues $\\lambda_1$ and $\\lambda_2$, we can apply parameter-shift method to find its gradient [1]:\n", + "\n", + "$$\n", + "\\nabla O(\\theta) = r \\left[O(\\theta+\\frac{\\pi}{4r}) - O(\\theta-\\frac{\\pi}{4r})\\right],\n", + "\\tag{4}\n", + "$$ \n", + "\n", + "where shift constant $r = \\frac{a}{2} (\\lambda_2 - \\lambda_1)$. Note that we're getting a theoretically exact gradient instead of an estimation like finite difference gradient. Moreover, this method doesn't require the construction of new circuits or adding ancilla qubits. Evaluations could be done just by changing the parameters inside the circuit.\n", + "\n", + "The fundamental rotation gates provided by Paddle Quantum are $R_x(\\theta), R_y(\\theta), R_z(\\theta)$ gates, which can be written as $e^{-i\\frac{1}{2}\\theta X}, e^{-i\\frac{1}{2}\\theta Y}, e^{-i\\frac{1}{2}\\theta Z}$ respectively. Since the eigenvalues of $X$, $Y$, and $Z$ gates are unique, which are -1 and 1, it's not hard to see that $r = \\frac{1}{2}$, and the gradient of those gates is just\n", + "\n", + "$$\n", + "\\frac{1}{2}[ O(\\theta + \\frac{\\pi}{2}) - O(\\theta - \\frac{\\pi}{2})].\n", + "\\tag{5}\n", + "$$\n", + "\n", + "We will demonstrate this formula's derivation using a single rotation gate $R_x$." + ] + }, + { + "cell_type": "markdown", + "id": "81a1defe", + "metadata": {}, + "source": [ + "### Derivation\n", + "\n", + "In this section, we will go through all the steps and arrive at the resulting formula for calculating $R_x$ gate's derivative. Using $R_x(\\theta)$ as $U(\\theta)$, we have\n", + "\n", + "$$\n", + "O(\\theta) = \\left\\langle0\\right| R_x^{\\dagger}(\\theta)HR_x(\\theta) \\left|0\\right\\rangle.\n", + "\\tag{6}\n", + "$$\n", + "\n", + "Given that $R_x(\\theta) = e^{-i\\frac{1}{2}\\theta X}$, where $X$ is the Pauli-X matrix, we know $\\frac{\\partial}{\\partial \\theta} R_x(\\theta) =-i\\frac{1}{2}Xe^{-i\\frac{\\theta}{2}X}=-i\\frac{1}{2}XR_x(\\theta)$. Using the product rule, its derivative can be written as\n", + "\n", + "$$\n", + "O'(\\theta) = \\left\\langle0\\right| [\\frac{i}{2}X] R_x^{\\dagger}(\\theta)HR_x(\\theta)\\left|0\\right\\rangle + \\left\\langle0\\right| R_x^{\\dagger}(\\theta)H [-\\frac{i}{2}X] R_x(\\theta)\\left|0\\right\\rangle.\n", + "\\tag{7}\n", + "$$\n", + "\n", + "We take out the shift constant $r$ in front for the purpose of later rearranging the equation using some trick, where $r$ for $R_x$ gate is $\\frac{1}{2}$. We have\n", + "\n", + "$$\n", + "O'(\\theta) = r \\left\\langle0\\right| [\\frac{i}{2r}X] R_x^{\\dagger}(\\theta)HR_x(\\theta)\\left|0\\right\\rangle + \\left\\langle0\\right| R_x^{\\dagger}(\\theta)H [-\\frac{i}{2r}X] R_x(\\theta)\\left|0\\right\\rangle.\n", + "\\tag{8}\n", + "$$\n", + "\n", + "Since we recognize that for any operators $U$, $V$ and $Q$, and for an arbitrary state $|\\psi\\rangle$, \n", + "\n", + "$$\n", + "\\langle\\psi|U^\\dagger QV|\\psi\\rangle + \\langle\\psi|V^\\dagger QU|\\psi\\rangle = \\frac{1}{2} \\big(\\langle\\psi|(U+V)^\\dagger Q(U+V)|\\psi\\rangle - \\langle\\psi|(U-V)^\\dagger Q(U-V)|\\psi\\rangle \\big),\n", + "\\tag{9}\n", + "$$\n", + "\n", + "we get \n", + "\n", + "$$\n", + "O'(\\theta) = \\frac{r}{2} \\big( \\left\\langle0\\right|R_x^{\\dagger}(\\theta) [I + \\frac{i}{2r}X]H[I - \\frac{i}{2r}X]R_x(\\theta)\\left|0\\right\\rangle - \\left\\langle0\\right| R_x^{\\dagger}(\\theta) [I - \\frac{i}{2r}X] H [I+\\frac{i}{2r}X] R_x(\\theta)\\left|0\\right\\rangle \\big).\n", + "\\tag{10}\n", + "$$\n", + "\n", + "Using Euler's identity and knowing that $G$ has two unique eigenvalues, we can rewrite $U(\\theta)$ as $e^{-ia\\theta G} = I\\cos(r\\theta) - i\\frac{a}{r}G\\sin(r\\theta)$ [1]. Thus, we have $R_x(\\theta) = I\\cos(r\\theta) - i\\frac{1}{2r}X\\sin(r\\theta)$, we notice that \n", + "\n", + "$$\n", + "R_x(\\frac{\\pi}{4r}) = I\\cos(\\frac{\\pi}{4}) - i\\frac{1}{2r}X\\sin(\\frac{\\pi}{4}) = \\frac{1}{\\sqrt2}(I-\\frac{i}{2r}X).\n", + "\\tag{11}\n", + "$$\n", + "\n", + "We can use the same method to get \n", + "\n", + "$$\n", + "R_x(-\\frac{\\pi}{4r}) = \\frac{1}{\\sqrt2}(I+\\frac{i}{2r}X).\n", + "\\tag{12}\n", + "$$\n", + "\n", + "Thus, the equation can be simplified to\n", + "\n", + "$$\n", + "O'(\\theta) = r\\big[ \\left\\langle0\\right|R_x^{\\dagger}(\\theta+\\frac{\\pi}{4r})HR_x(\\theta+\\frac{\\pi}{4r})\\left|0\\right\\rangle - \\left\\langle0\\right| R_x^{\\dagger}(\\theta-\\frac{\\pi}{4r}) H R_x(\\theta-\\frac{\\pi}{4r})\\left|0\\right\\rangle \\big],\n", + "\\tag{13}\n", + "$$\n", + "\n", + "and get the final formula,\n", + "\n", + "$$\n", + "O'(\\theta) = r\\big[O(\\theta+\\frac{\\pi}{4r}) - O(\\theta-\\frac{\\pi}{4r}))\\big] = \\frac{1}{2}\\big[ O(\\theta + \\frac{\\pi}{2}) - O(\\theta - \\frac{\\pi}{2})\\big].\n", + "\\tag{14}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "id": "c460666d", + "metadata": {}, + "source": [ + "### Paddle Quantum implementation\n", + "Here we demonstrate how to use Paddle Quantum's built-in parameter shift method to calculate the gradient. Note: The built-in method currently does not support assigning an input state or running on a noisy circuit." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "18d78ca9", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--Ry(5.690)----*----x----Ry(3.107)--\n", + " | | \n", + "--Ry(2.521)----x----*----Ry(0.437)--\n", + " \n", + "Gradient of this objective function is: [-0.79156457 0.12584274 -0.2654174 0.7806864 ]\n" + ] + } + ], + "source": [ + "# We reuse the predefined Hamiltonian H and parameters of the circuit. \n", + "# Again, be sure to mark stop_gradient=False when defining tensor for parameters of the circuit.\n", + "\n", + "# Constructing circuit U(theta)\n", + "cir = U_theta(theta_tensor)\n", + "print(cir)\n", + "\n", + "gradients = cir.param_shift_gradient(H)\n", + "print(\"Gradient of this objective function is: \", gradients.numpy())" + ] + }, + { + "cell_type": "markdown", + "id": "2490a251", + "metadata": {}, + "source": [ + "## Linear Combination of Unitary Gradients\n", + "\n", + "Building a parameterized circuit $U(\\theta)$ using Paddle Quantum requires many parameterized one-qubit and two-qubit gates like $R_x$ and $CR_x$. So we can rewrite $U(\\theta)$ as $U_{1}(\\theta_1)U_{2}(\\theta_2)\\cdots U_{m}(\\theta_m)$, where $U_i(\\theta_i)$ is one of the one-qubit and two-qubit gates and $m$ is the total number of parameterized gates in this circuit $U(\\theta)$. To get the gradient of an individual parameter, we consider this equation $\\frac{\\partial U(\\theta)}{\\partial \\theta_i}=U_{1}(\\theta_1)U_{2}(\\theta_2)\\cdots\\frac{\\partial U_i{(\\theta_i)}}{\\partial \\theta_i}\\cdots U_{m}(\\theta_m)$. We notice that as long as we know $\\frac{\\partial U_i{(\\theta_i)}}{\\partial \\theta_i}$ for all parameterized gates, we can get the gradients for all parameters easily [2]." + ] + }, + { + "cell_type": "markdown", + "id": "8c98fb33", + "metadata": {}, + "source": [ + "### Single qubit gate gradient\n", + "\n", + "Let's consider single qubit gates first. We also take $R_x(\\theta)$ as an example. In the previous sections, we've already shown that $\\frac{\\partial R_x(\\theta)}{\\partial \\theta}=-i\\frac{1}{2}XR_x(\\theta)$, which can be easily constructed using a circuit. Let's try to implement it using Paddle Quantum." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "97435cf4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Original circuit: \n", + "--Rx(1.047)--\n", + " \n", + "The circuit for gradient of Rx: \n", + "------------x----Rx(1.047)--\n", + " | \n", + "--H---SDG---*--------H------\n", + " \n" + ] + } + ], + "source": [ + "# Construct the circuit with a single one-qubit gate Rx\n", + "theta = paddle.to_tensor(np.pi / 3, 'float64')\n", + "cir = UAnsatz(1)\n", + "cir.rx(theta, 0)\n", + "print('Original circuit: ')\n", + "print(cir)\n", + "\n", + "print('The circuit for gradient of Rx: ')\n", + "# The first parameter here is the index of the gate, the second parameter is the name of the gate\n", + "print(cir.pauli_rotation_gate_partial(0, 'rx'))" + ] + }, + { + "cell_type": "markdown", + "id": "e3d30aa3", + "metadata": {}, + "source": [ + "It's a lot more complicated to do the same for a $u3(\\theta, \\phi, \\lambda)$ gate. But don't worry, we provide built-in methods for generating the circuits needed for calculating gradients of all parameterized single qubit gates in Paddle Quantum, i.e., $R_x$, $R_y$, $R_z$, and $u3$. " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "6a7e5f3c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Original circuit: \n", + "--U--\n", + " \n", + "Circuits for gradient of u3: \n", + "------------z----U--\n", + " | \n", + "--H---SDG---*----H--\n", + " \n", + "--Rz(4.706)---------y----Ry(3.292)----Rz(1.748)--\n", + " | \n", + "------H-------SDG---*--------H-------------------\n", + " \n", + "--Rz(4.706)----Ry(3.292)----z----Rz(1.748)--\n", + " | \n", + "------H-----------SDG-------*--------H------\n", + " \n" + ] + } + ], + "source": [ + "cir = UAnsatz(1)\n", + "theta = paddle.uniform([3], min=0.0, max=2*np.pi, dtype='float64')\n", + "cir.u3(theta[0], theta[1], theta[2], 0)\n", + "print('Original circuit: ')\n", + "print(cir)\n", + "\n", + "# Since the u3 gate has three parameters, we need a total of three circuits. Each corresponds to one parameter.\n", + "print('Circuits for gradient of u3: ')\n", + "# The first parameter here is the index of the gate, the second parameter is the index of parameter\n", + "print(cir.u3_partial(0, 0))\n", + "print(cir.u3_partial(0, 1))\n", + "print(cir.u3_partial(0, 2))" + ] + }, + { + "cell_type": "markdown", + "id": "95d11a2b", + "metadata": {}, + "source": [ + "### Two-qubit gate gradient\n", + "\n", + "Paddle Quantum provides many two-qubit parameterized gates as well. They can be categorized into two types: one is control rotation gates like $CR_x$, the other is two-qubit rotation gates like $R_{xx}$. Circuits for gradients of two-qubit rotation gates are easy to construct. Let's take $R_{xx}$ as an example. Following the idea of one-qubit rotation gates, we first write it as $R_{xx}(\\theta)=e^{-i\\frac{\\theta}{2}X\\otimes X}$, then get the equation $\\frac{\\partial R_{xx}(\\theta)}{\\partial \\theta}=-i\\frac{1}{2}X\\otimes Xe^{-i\\frac{\\theta}{2}X\\otimes X}$, which can be converted into a circuit easily." + ] + }, + { + "cell_type": "markdown", + "id": "3fe81c6c", + "metadata": {}, + "source": [ + "We need to be careful when calculating the gradients for control rotation gates. Usually, we will need two circuits for a control rotation gate with one parameter. For example, let's consider $CR_x(\\theta)$.\n", + "\n", + "$CR_x(\\theta)$ can be written as $\\left|0\\right>\\left<0\\right|\\otimes I + \\left|1\\right>\\left<1\\right|\\otimes R_x(\\theta)$, so its gradient is: \n", + "\n", + "$$\n", + "\\frac{\\partial CR_x(\\theta)}{\\partial \\theta}=\\left|1\\right>\\left<1\\right|\\otimes \\frac{\\partial R_x(\\theta)}{\\partial \\theta}=-\\frac{i}{2}\\left|1\\right>\\left<1\\right|\\otimes Xe^{-i\\frac{\\theta}{2}X}.\n", + "\\tag{15}\n", + "$$\n", + "\n", + "However, this equation cannot be represented directly using one circuit. We need to use a tiny 'trick' here. Instead of using this formula directly, we decompose it into two terms \n", + "\n", + "$$\n", + "\\frac{\\partial CR_x(\\theta)}{\\partial \\theta}=-\\frac{i}{4}(\\left|0\\right>\\left<0\\right|\\otimes I + \\left|1\\right>\\left<1\\right|\\otimes R_x(\\theta))I\\otimes X + \\frac{i}{4}(\\left|0\\right>\\left<0\\right|\\otimes I + \\left|1\\right>\\left<1\\right|\\otimes R_x(\\theta))Z\\otimes X.\n", + "\\tag{16}\n", + "$$ \n", + "\n", + "You can easily verify that this formula is equivalent to the former one. By doing so, we can use two circuits to compute the gradients for $CR_x$." + ] + }, + { + "cell_type": "markdown", + "id": "23a999c4", + "metadata": {}, + "source": [ + "As always, we provide built-in methods for calculating the gradients of all two-qubit parameterized gates in Paddle Quantum, i.e., $R_{xx}$, $R_{yy}$, $R_{zz}$, $CR_x$, $CR_y$, $CR_z$, $CU$. " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "59733ca2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Original circuit: \n", + "--*----Rzz(3.76)--------*------\n", + " | | | \n", + "--U----Rzz(3.76)----Ry(2.246)--\n", + " \n", + "The circuit for gradient of rzz: \n", + "--*---------z---------Rzz(3.76)--------*------\n", + " | | | | \n", + "--U---------|----z----Rzz(3.76)----Ry(2.246)--\n", + " | | \n", + "--H---SDG---*----*--------H-------------------\n", + " \n", + "The circuit for gradient of cry: \n", + "--*----Rzz(3.76)----y--------*------\n", + " | | | | \n", + "--U----Rzz(3.76)----|----Ry(2.246)--\n", + " | \n", + "--H-------SDG-------*--------H------\n", + " \n", + "--*----Rzz(3.76)---------y--------*------\n", + " | | | | \n", + "--U----Rzz(3.76)----z----|----Ry(2.246)--\n", + " | | \n", + "--H--------S--------*----*--------H------\n", + " \n" + ] + } + ], + "source": [ + "theta = paddle.uniform([5], min=0.0, max=2*np.pi, dtype='float64')\n", + "cir = UAnsatz(2)\n", + "cir.cu(theta[0], theta[1], theta[2], [0, 1])\n", + "cir.rzz(theta[3], [0, 1])\n", + "cir.cry(theta[4], [0, 1])\n", + "print('Original circuit: ')\n", + "print(cir)\n", + "\n", + "# The first parameter here is the index of the gate, the second parameter is the index of parameter\n", + "# Since we have three parameters for cu gate, and we need two circuits for each parameter, we have a total of 6 circuits.\n", + "# Circuits for gradients of cu:\n", + "cu3_00 = cir.cu3_partial(0, 0)[0]\n", + "cu3_01 = cir.cu3_partial(0, 0)[1]\n", + "cu3_10 = cir.cu3_partial(0, 1)[0]\n", + "cu3_11 = cir.cu3_partial(0, 1)[1]\n", + "cu3_20 = cir.cu3_partial(0, 2)[0]\n", + "cu3_21 = cir.cu3_partial(0, 2)[1]\n", + "\n", + "# The first parameter here is the index of the gate, the second parameter is the name of the gate\n", + "print('The circuit for gradient of rzz: ')\n", + "print(cir.pauli_rotation_gate_partial(1, 'RZZ_gate'))\n", + "\n", + "# The first parameter here is the index of the gate, the second parameter is the name of the gate\n", + "print('The circuit for gradient of cry: ')\n", + "print(cir.control_rotation_gate_partial(2, 'cry')[0])\n", + "print(cir.control_rotation_gate_partial(2, 'cry')[1])" + ] + }, + { + "cell_type": "markdown", + "id": "9d264a86", + "metadata": {}, + "source": [ + "Now that we have all individual circuits prepared for calculating gradients, the next step is to get the exact value of the gradients. How to do so? We need to plug these circuits into our objective function, then the results are our desired gradients. For gates like $CR_x$, we will take the mean of the two circuits to be the gradient, as indicated in the analytical formula. We also provide a built-in method (Note: The built-in method currently does not support assigning an input state or running on a noisy circuit):" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "02e8ea72", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--U----*----x----Ry(0.667)--\n", + " | | \n", + "--U----x----*----Ry(4.807)--\n", + " \n", + "Gradient of this objective function is: [ 0. -0.76471634 0.00700639 0. -0.29062181 -0.01701887\n", + " -0.07729092 0.7766131 ]\n" + ] + } + ], + "source": [ + "# Randomly generate parameters for our circuit\n", + "theta = paddle.uniform(shape=[8], dtype='float64', min=0.0, max=np.pi * 2)\n", + "theta.stop_gradient = False\n", + "\n", + "# Construct circuit of U(theta)\n", + "cir = UAnsatz(2)\n", + "cir.complex_entangled_layer(theta[:6], 1)\n", + "cir.ry(theta=theta[6], which_qubit=0)\n", + "cir.ry(theta=theta[7], which_qubit=1)\n", + "cir.run_state_vector()\n", + "print(cir)\n", + "\n", + "# Calculate gradient using our built-in method\n", + "# We pass in our Hamiltonian H used in the objective function\n", + "gradient = cir.linear_combinations_gradient(H, shots=0)\n", + "print(\"Gradient of this objective function is: \", gradient.numpy())" + ] + }, + { + "cell_type": "markdown", + "id": "d7fcdbdf", + "metadata": {}, + "source": [ + "## Application: Simulating VQE with Paddle Quantum\n", + "\n", + "Variational Quantum Eigensolver (VQE) [3] is designed to find the ground state energy of a given molecular Hamiltonian using variational quantum circuits. Interested readers can find more details from the previous tutorial [VQE](../quantum_simulation/VQE_EN.ipynb).\n", + "\n", + "We will demonstrate how to use VQE to find the ground state energy for the Hamiltonian of hydrogen molecule $H_2$. In the process, we will use the methods introduced above to calculate the gradient." + ] + }, + { + "cell_type": "markdown", + "id": "8e9d6e7b", + "metadata": {}, + "source": [ + "### Using Paddle's Optimizer\n", + "\n", + "First, we will use Paddle's optimizer Adam to run our example. We can choose using either finite difference method or parameter-shift method to calculate gradient." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "cce057c2", + "metadata": {}, + "outputs": [], + "source": [ + "from paddle_quantum.VQE.chemistrysub import H2_generator\n", + "from paddle_quantum.expecval import ExpecVal\n", + "\n", + "# Set up our Hamiltonian H\n", + "pauli_str, N = H2_generator()\n", + "H = Hamiltonian(pauli_str)\n", + "\n", + "# Hyper-parameters\n", + "ITR = 80 # Set the number of optimization iterations\n", + "LR = 0.4 # Set the learning rate\n", + "D = 2 # Set the depth of the repetitive calculation module in QNN\n", + "\n", + "def U_theta(theta, Hamiltonian, N, D):\n", + " \"\"\"\n", + " Quantum Neural Network\n", + " \"\"\"\n", + " # Initialize the quantum neural network according to the number of qubits N\n", + " cir = UAnsatz(N)\n", + "\n", + " # Built-in {R_y + CNOT} circuit template\n", + " theta = paddle.reshape(theta, [D+1, N, 1])\n", + " cir.real_entangled_layer(theta[:D], D)\n", + "\n", + " # Lay R_y gates in the last row\n", + " for i in range(N):\n", + " cir.ry(theta=theta[D][i][0], which_qubit=i)\n", + "\n", + " # The quantum neural network acts on the default initial state |0...0>\n", + " cir.run_state_vector()\n", + " \n", + " return cir" + ] + }, + { + "cell_type": "markdown", + "id": "c0cdee79", + "metadata": {}, + "source": [ + "Here in our forward propagation mechanism, we use the updated parameters to calculate gradient using parameter-shift rule, and calculate the expectation value. You can change the method to 'finite_diff' if you'd like to try it out using finite difference method. " + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "0d172081", + "metadata": {}, + "outputs": [], + "source": [ + "class StateNet(paddle.nn.Layer):\n", + "\n", + " def __init__(self, cir):\n", + " super(StateNet, self).__init__()\n", + " \n", + " self.cir = cir\n", + " params = cir.get_param()\n", + " \n", + " # Assign the theta parameter list to be the trainable parameter list of the circuit\n", + " self.theta = self.create_parameter(shape=[len(params)], \n", + " default_initializer=paddle.nn.initializer.Assign(params),\n", + " dtype='float32', is_bias=False)\n", + " \n", + " # Define loss function and forward propagation mechanism\n", + " def forward(self):\n", + " # Calculate the loss function/expectation value using Parameter-shift rule to calculate gradient\n", + " loss = ExpecVal.apply(self.cir, self.theta.cast('float64'), 'param_shift', H, shots=0)\n", + " \n", + " return loss, self.cir" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "0b8235c9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "iter: 20 loss: -1.1114\n", + "iter: 20 Ground state energy: -1.1114 Ha\n", + "iter: 40 loss: -1.1316\n", + "iter: 40 Ground state energy: -1.1316 Ha\n", + "iter: 60 loss: -1.1357\n", + "iter: 60 Ground state energy: -1.1357 Ha\n", + "iter: 80 loss: -1.1361\n", + "iter: 80 Ground state energy: -1.1361 Ha\n", + "\n", + "The trained circuit:\n", + "--Ry(6.282)----*--------------x----Ry(6.289)----*--------------x----Ry(3.148)--\n", + " | | | | \n", + "--Ry(3.138)----x----*---------|----Ry(0.207)----x----*---------|----Ry(3.142)--\n", + " | | | | \n", + "--Ry(6.278)---------x----*----|----Ry(0.001)---------x----*----|----Ry(3.143)--\n", + " | | | | \n", + "--Ry(0.001)--------------x----*----Ry(3.156)--------------x----*----Ry(3.154)--\n", + " \n", + "\n", + "Ground state energy obtained: [-1.13609609] Ha\n", + "Actual ground state energy: -1.13618 Ha\n" + ] + } + ], + "source": [ + "# Initialize the theta parameter list and fill the initial value with a uniform distribution of [0, 2*pi]\n", + "theta = paddle.to_tensor(np.random.uniform(0.0, 2*np.pi, (D+1) * N), stop_gradient=False)\n", + "\n", + "# Initialize the circuit\n", + "cir = U_theta(theta, H, N, D)\n", + "\n", + "# Determine the parameter dimension of the network\n", + "net = StateNet(cir)\n", + "\n", + "# Generally speaking, we use Adam optimizer to obtain relatively good convergence,\n", + "# You can change it to SGD or RMS prop.\n", + "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters())\n", + "\n", + "# Record optimization results\n", + "summary_iter, summary_loss = [], []\n", + "\n", + "# Optimization loop\n", + "for itr in range(1, ITR + 1):\n", + "\n", + " # Forward propagation to calculate loss function\n", + " loss, cir = net()\n", + "\n", + " # Use back propagation to minimize the loss function\n", + " loss.backward()\n", + " opt.minimize(loss)\n", + " opt.clear_grad()\n", + "\n", + " # Record optimization results\n", + " summary_loss.append(loss.numpy())\n", + " summary_iter.append(itr)\n", + "\n", + " # Print result\n", + " if itr % 20 == 0:\n", + " print(\"iter:\", itr, \"loss:\", \"%.4f\" % loss.numpy())\n", + " print(\"iter:\", itr, \"Ground state energy:\", \"%.4f Ha\" \n", + " % loss.numpy())\n", + " if itr == ITR:\n", + " print(\"\\nThe trained circuit:\")\n", + " print(cir)\n", + "\n", + "print('\\nGround state energy obtained: ', summary_loss[-1], \"Ha\")\n", + "print('Actual ground state energy: ', -1.13618, \"Ha\")" + ] + }, + { + "cell_type": "markdown", + "id": "2e672bed", + "metadata": {}, + "source": [ + "We can see that the ground state energy we obtained is close to the theoretical value." + ] + }, + { + "cell_type": "markdown", + "id": "8d58ebab", + "metadata": {}, + "source": [ + "### Using SciPy's Optimizer\n", + "\n", + "We will also demonstrate how to use SciPy's optimizer to run VQE easily with Paddle Quantum. For this example, we will use Conjugate Gradient (CG) optimizer along with linear combination method to find the ground state energy of our Hamiltonian. \n", + "\n", + "Other SciPy methods we support include Newton-CG, Powell, and SLSQP." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "7f7ef671", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss: [-0.91176578]\n", + "loss: [-1.03555093]\n", + "loss: [-1.11965221]\n", + "loss: [-1.13435502]\n", + "loss: [-1.13577104]\n", + "loss: [-1.13615947]\n", + "loss: [-1.13618601]\n", + "loss: [-1.13618942]\n", + "loss: [-1.13618945]\n", + "loss: [-1.13618945]\n", + "loss: [-1.13618945]\n", + "Optimization terminated successfully.\n", + "Actual ground state energy: -1.13618 Ha\n" + ] + } + ], + "source": [ + "from paddle_quantum.optimizer import ConjugateGradient\n", + "\n", + "# Initialize the circuit\n", + "cir = U_theta(theta, H, N, D)\n", + "\n", + "optimizer = ConjugateGradient(cir, H, shots=0, grad_func_name='linear_comb')\n", + "optimizer.minimize(iterations=80)\n", + "print('Actual ground state energy: ', -1.13618, \"Ha\")" + ] + }, + { + "cell_type": "markdown", + "id": "1ad4927e", + "metadata": {}, + "source": [ + "## Conclusion\n", + "\n", + "As you can see, finite-difference and parameter-shift methods have similar forms - both of them require two function evaluations per parameter. The benefits of these methods are that the gradients can be calculated without knowing much about the circuit or the objective function. We can treat them as a black box and get the gradient just by feeding in different parameters. Our preferred choice between those two is parameter-shift method because its result is an analytical gradient, while finite difference method can only get an estimation of the gradient. However, parameter-shift only applies to $U(\\theta)$ that can be generated by $G$ that has two distinct eigenvalues: $U(\\theta) = e^{-ia\\theta G}$ or can be decomposed into a product of gates in this form.\n", + "\n", + "Using linear combination of unitary gates to calculate the gradients of a given circuit is probably the most straightforward analytical method. By differentiating unitary gates under their mathematical forms, we can use circuits to represent the resulting formula. The number of circuits required is proportional to the number of parameters in the original circuit as the other two methods. We can even calculate gradients by constructing only one single circuit for simple gates like $R_x$, $R_{xx}$ and etc. However, note that we will use an ancilla qubit in this method. Moreover, you might have noticed that this method takes a long time to run on complex circuits. That's because as the number of qubits increases, the number of circuits used to represent the first order differentiation of a single multi-qubit gate also increases. " + ] + }, + { + "cell_type": "markdown", + "id": "26a8f5fd", + "metadata": {}, + "source": [ + "_______\n", + "\n", + "## References\n", + "\n", + "[1] Crooks, Gavin E. \"Gradients of parameterized quantum gates using the parameter-shift rule and gate decomposition.\" [arXiv preprint arXiv:1905.13311 (2019)](https://arxiv.org/abs/1905.13311).\n", + "\n", + "[2] Somma, Rolando, et al. \"Simulating physical phenomena by quantum networks.\" [Physical Review A 65.4 (2002): 042323](https://arxiv.org/abs/quant-ph/0108146).\n", + "\n", + "[3] Peruzzo, Alberto, et al. \"A variational eigenvalue solver on a photonic quantum processor.\" [Nature communications 5.1 (2014): 1-7](https://www.nature.com/articles/ncomms5213).\n", + "\n", + "[4] Schuld, Maria, et al. \"Evaluating analytic gradients on quantum hardware.\" [Physical Review A 99.3 (2019): 032331](https://arxiv.org/abs/1811.11184)." + ] + } + ], + "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.7.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tutorial/qnn_research/Noise_CN.ipynb b/tutorial/qnn_research/Noise_CN.ipynb index 3cfbb7e..a6e8399 100644 --- a/tutorial/qnn_research/Noise_CN.ipynb +++ b/tutorial/qnn_research/Noise_CN.ipynb @@ -2,7 +2,6 @@ "cells": [ { "cell_type": "markdown", - "id": "6a2df459", "metadata": {}, "source": [ "# 在 Paddle Quantum 中模拟含噪量子电路\n", @@ -12,7 +11,6 @@ }, { "cell_type": "markdown", - "id": "d12197db", "metadata": {}, "source": [ "## 噪声简介\n", @@ -79,7 +77,6 @@ }, { "cell_type": "markdown", - "id": "84556435", "metadata": {}, "source": [ "### Paddle Quantum 中添加信道的方式\n", @@ -90,7 +87,6 @@ { "cell_type": "code", "execution_count": 1, - "id": "ff3880f1", "metadata": { "ExecuteTime": { "end_time": "2021-04-08T05:16:08.247239Z", @@ -140,7 +136,6 @@ }, { "cell_type": "markdown", - "id": "863e4554", "metadata": {}, "source": [ "之后，我们加上一个 $p=0.1$ 的比特反转噪声，并测量通过信道之后的量子比特。 \n", @@ -150,7 +145,6 @@ { "cell_type": "code", "execution_count": 2, - "id": "70674a65", "metadata": { "ExecuteTime": { "end_time": "2021-04-08T05:16:09.221527Z", @@ -199,7 +193,6 @@ }, { "cell_type": "markdown", - "id": "0c42a154", "metadata": {}, "source": [ "可以看到，经过了比特反转信道（概率为 $p=0.1$）之后的量子态变成了混合态 $0.9 | 0 \\rangle \\langle 0 | + 0.1 | 1 \\rangle \\langle 1 |$。\n", @@ -208,7 +201,6 @@ }, { "cell_type": "markdown", - "id": "3725bece", "metadata": {}, "source": [ "### 常用噪声信道\n", @@ -216,7 +208,7 @@ "除了比特反转信道之外，Paddle Quantum 也支持模拟其他常用的噪声信道。\n", "\n", "\n", - "- **相位反转信道（phase flip channel）**\n", + "- **相位反转信道（Phase Flip Channel）**\n", "\n", " 与比特反转信道类似，相位反转信道会以 $p$ 的概率来反转一个量子比特的相位，其表达形式为\n", " \n", @@ -226,7 +218,7 @@ " $$\n", "\n", "\n", - "- **比特相位反转信道（bit-phase flip channel）**\n", + "- **比特相位反转信道（Bit-Phase Flip Channel）**\n", "\n", " $$\n", " \\mathcal{E}_{BPF}(\\rho) = (1-p) \\rho + p Y \\rho Y.\n", @@ -234,7 +226,7 @@ " $$\n", "\n", "\n", - "- **去极化信道 （depolarizing channel）**\n", + "- **去极化信道 （Depolarizing Channel）**\n", "\n", " 通过去极化信道之后，将会有 $p$ 的概率处于最大混态 $I/2$ 和 $1-p$ 的概率维持不变。可以表示为对称地施加泡利噪声，\n", " \n", @@ -245,7 +237,7 @@ " $$\n", "\n", "\n", - "- **泡利信道（Pauli channel）**\n", + "- **泡利信道（Pauli Channel）**\n", "\n", " 该信道会以非对称的形式施加泡利噪声。表达形式为\n", " \n", @@ -255,7 +247,7 @@ " $$\n", "\n", "\n", - "- **振幅阻尼信道（amplitude damping channel）**\n", + "- **振幅阻尼信道（Amplitude Damping Channel）**\n", "\n", " 振幅阻尼信道可以用来模拟当系统受到**能量耗散**时引入的噪声。表达形式为，\n", " \n", @@ -279,7 +271,7 @@ " $$ \n", "\n", "\n", - "- **相位阻尼信道（phase damping channel）**\n", + "- **相位阻尼信道（Phase Damping Channel）**\n", "\n", " 相位阻尼信道描述的是当系统没有与外界环境交换能量，却损失了**量子信息**的情况下的噪声模型。其表达形式为\n", " \n", @@ -303,7 +295,7 @@ " $$\n", "\n", "\n", - "- **广义振幅阻尼信道（generalized amplitude Damping channel）**\n", + "- **广义振幅阻尼信道（Generalized Amplitude Damping Channel）**\n", "\n", " 该信道描述的是系统与外界环境在**有限温度下交换能量**的噪声模型，同时也是**超导量子计算中的常见噪声** [4]。其表达形式较为复杂，感兴趣的读者可以进一步的阅读 [API 文档](https://qml.baidu.com/api/paddle_quantum.circuit.uansatz.html) 和相应的参考文献。\n", "\n", @@ -315,7 +307,6 @@ }, { "cell_type": "markdown", - "id": "213994a9", "metadata": {}, "source": [ "### 自定义信道\n", @@ -326,7 +317,6 @@ { "cell_type": "code", "execution_count": 3, - "id": "020ab93f", "metadata": { "ExecuteTime": { "end_time": "2021-04-08T05:17:30.681411Z", @@ -385,7 +375,6 @@ }, { "cell_type": "markdown", - "id": "df1c24d9", "metadata": {}, "source": [ "按照上述例子，用户可以通过自定义 *Kraus* 算符的方式实现特定的信道。" @@ -393,19 +382,17 @@ }, { "cell_type": "markdown", - "id": "e97e1bcd", "metadata": {}, "source": [ "## 拓展：Paddle Quantum 模拟含噪纠缠资源\n", "\n", "\n", - "许多重要的量子技术，例如量子隐形传态、态转换、分布式量子计算等都需要纠缠资源的预先分配。以纠缠量子比特对为例，在理想情况下，我们希望分配的纠缠资源处于**最大纠缠态**（maximally entangled state)。但是在实际的应用中，纠缠资源往往在制备、传输以及保存的过程中会和环境发生相互作用，从而引入噪声。下面，我们用 Paddle Quantum 中的去极化信道来模拟一个简单的场景，白噪声对贝尔态的影响：" + "许多重要的量子技术，例如量子隐形传态、态转换、分布式量子计算等都需要纠缠资源的预先分配。以纠缠量子比特对为例，在理想情况下，我们希望分配的纠缠资源处于**最大纠缠态**（Maximally entangled state)。但是在实际的应用中，纠缠资源往往在制备、传输以及保存的过程中会和环境发生相互作用，从而引入噪声。下面，我们用 Paddle Quantum 中的去极化信道来模拟一个简单的场景，白噪声对贝尔态的影响：" ] }, { "cell_type": "code", "execution_count": 4, - "id": "2a73505a", "metadata": { "ExecuteTime": { "end_time": "2021-04-08T05:24:35.552425Z", @@ -463,7 +450,6 @@ }, { "cell_type": "markdown", - "id": "85c5fcc6", "metadata": {}, "source": [ "**注释：** 在 [纠缠蒸馏](../locc/EntanglementDistillation_LOCCNET_CN.ipynb) 的教程中我们介绍了如何利用 Paddle Quantm 中的 LoccNet 模块来研究纠缠蒸馏，即利用多个含噪声的纠缠对来提取高保真度的纠缠对，感兴趣的读者可以前往阅读。" @@ -471,13 +457,12 @@ }, { "cell_type": "markdown", - "id": "2e42f021", "metadata": {}, "source": [ "## 应用： Paddle Quantum 模拟含噪变分量子本征求解器（VQE）\n", "\n", "\n", - "变分量子本征求解器（variational quantum eigensolver, VQE）[5] 可以用变分量子电路来计算某个给定哈密顿量的基态能量，关于其具体的原理和背景在之前的教程 [变分量子本征求解器](../quantum_simulation/VQE_CN.ipynb) 中有详细的讲解，感兴趣的读者可以前往阅读。\n", + "变分量子本征求解器（Variational Quantum Eigensolver）[5] 可以用变分量子电路来计算某个给定哈密顿量的基态能量，关于其具体的原理和背景在之前的教程 [变分量子本征求解器](../quantum_simulation/VQE_CN.ipynb) 中有详细的讲解，感兴趣的读者可以前往阅读。\n", "\n", "在这里，我们尝试用一个简单的 VQE 电路来求解如下哈密顿量的基态能量：\n", "\n", @@ -492,7 +477,6 @@ { "cell_type": "code", "execution_count": 5, - "id": "ab0fff8f", "metadata": { "ExecuteTime": { "end_time": "2021-04-08T05:34:47.301281Z", @@ -524,7 +508,6 @@ { "cell_type": "code", "execution_count": 6, - "id": "b498f6c6", "metadata": { "ExecuteTime": { "end_time": "2021-04-08T05:34:51.742273Z", @@ -683,7 +666,6 @@ }, { "cell_type": "markdown", - "id": "48e09aa7", "metadata": {}, "source": [ "可以看到，含噪的变分量子本征求解器的效果要差于不含噪的版本，无法达到化学精度的要求 $\\varepsilon = 0.0016$ Ha。" @@ -691,7 +673,6 @@ }, { "cell_type": "markdown", - "id": "8e0b51c6", "metadata": {}, "source": [ "## 总结\n", @@ -701,7 +682,6 @@ }, { "cell_type": "markdown", - "id": "ea92b769", "metadata": {}, "source": [ "---\n", @@ -736,7 +716,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.10" + "version": "3.8.3" }, "toc": { "base_numbering": 1, diff --git a/tutorial/quantum_simulation/SSVQE_CN.ipynb b/tutorial/quantum_simulation/SSVQE_CN.ipynb index 89dfc51..136e939 100644 --- a/tutorial/quantum_simulation/SSVQE_CN.ipynb +++ b/tutorial/quantum_simulation/SSVQE_CN.ipynb @@ -2,7 +2,6 @@ "cells": [ { "cell_type": "markdown", - "metadata": {}, "source": [ "# 子空间搜索-量子变分本征求解器\n", "\n", @@ -13,18 +12,12 @@ "- 在本案例中，我们将展示如何通过 Paddle Quantum 训练量子神经网络来求解量子系统的整个能量谱。\n", "\n", "- 首先，让我们通过下面几行代码引入必要的 library 和 package。" - ] + ], + "metadata": {} }, { "cell_type": "code", "execution_count": 1, - "metadata": { - "ExecuteTime": { - "end_time": "2021-04-30T09:12:57.571029Z", - "start_time": "2021-04-30T09:12:54.960356Z" - } - }, - "outputs": [], "source": [ "import numpy\n", "from numpy import pi as PI\n", @@ -32,89 +25,89 @@ "from paddle import matmul\n", "from paddle_quantum.circuit import UAnsatz\n", "from paddle_quantum.utils import random_pauli_str_generator, pauli_str_to_matrix, dagger" - ] + ], + "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2021-04-30T09:12:57.571029Z", + "start_time": "2021-04-30T09:12:54.960356Z" + } + } }, { "cell_type": "markdown", - "metadata": {}, "source": [ "## 背景\n", "\n", "- 量子计算在近期内备受瞩目的一个应用就是变分量子本征求解器（variational quantum eigensolver, VQE）[1-3].\n", - "- VQE 是量子化学在近期有噪量子设备（NISQ device）上的核心应用之一，其中一个功能比较强大的版本是 subspace-search VQE（SSVQE） [4]，其核心是去求解一个物理系统的哈密顿量（Hamiltonian）的基态和**激发态**的性质。数学上，可以理解为求解一个埃尔米特矩阵矩阵（Hermitian matrix）的本征值及其对应的本征向量。该哈密顿量的本征值组成的集合我们称其为能谱（energy spectrum）。\n", + "- VQE 是量子化学在近期有噪量子设备（NISQ device）上的核心应用之一，其中一个功能比较强大的版本是 subspace-search VQE（SSVQE） [4]，其核心是去求解一个物理系统的哈密顿量（Hamiltonian）的基态和**激发态**的性质。数学上，可以理解为求解一个埃尔米特矩阵（Hermitian matrix）的本征值及其对应的本征向量。该哈密顿量的本征值组成的集合我们称其为能谱（energy spectrum）。\n", "- 接下来我们将通过一个简单的例子学习如何通过训练量子神经网络解决这个问题，即求解出给定哈密顿量 $H$ 的能谱。\n", "\n", "## SSVQE 分析物理系统的基态和激发态的能量\n", "\n", "- 对于具体需要分析的分子，我们需要其几何构型（geometry）、电荷（charge）以及自旋多重度（spin multiplicity）等多项信息来建模获取描述系统的 Hamilton 量。具体的，通过我们内置的量子化学工具包可以利用 fermionic-to-qubit 映射的技术来输出目标分子的量子比特 Hamilton 量表示。\n", "- 作为简单的入门案例，我们在这里提供一个简单的随机双量子比特 Hamilton 量作为例子。" - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, + "source": [ + "N = 2 # 量子比特数/量子神经网络的宽度\n", + "SEED = 14 # 固定随机种子" + ], + "outputs": [], "metadata": { "ExecuteTime": { "end_time": "2021-04-30T09:12:57.580461Z", "start_time": "2021-04-30T09:12:57.574080Z" } - }, - "outputs": [], - "source": [ - "N = 2 # 量子比特数/量子神经网络的宽度\n", - "SEED = 14 # 固定随机种子" - ] + } }, { "cell_type": "code", - "execution_count": 3, - "metadata": { - "ExecuteTime": { - "end_time": "2021-04-30T09:12:57.604652Z", - "start_time": "2021-04-30T09:12:57.592553Z" - } - }, + "execution_count": 8, + "source": [ + "# 生成用泡利字符串表示的随机哈密顿量\n", + "numpy.random.seed(SEED)\n", + "hamiltonian = random_pauli_str_generator(N, terms=10)\n", + "print(\"Random Hamiltonian in Pauli string format = \\n\", hamiltonian)\n", + "\n", + "# 生成 Hamilton 量的矩阵信息\n", + "H = pauli_str_to_matrix(hamiltonian, N)" + ], "outputs": [ { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ "Random Hamiltonian in Pauli string format = \n", " [[0.9152074787317819, 'x1,y0'], [-0.2717604556798945, 'z0'], [0.3628495008719168, 'x0'], [-0.5050129214094752, 'x1'], [-0.6971554357833791, 'y0,x1'], [0.8651151857574237, 'x0,y1'], [0.7409989105435002, 'y0'], [-0.39981603921243236, 'y0'], [0.06862640764702, 'z0'], [-0.7647553733438246, 'y1']]\n" ] } ], - "source": [ - "# 生成用泡利字符串表示的随机哈密顿量\n", - "numpy.random.seed(SEED)\n", - "hamiltonian = random_pauli_str_generator(N, terms=10)\n", - "print(\"Random Hamiltonian in Pauli string format = \\n\", hamiltonian)\n", - "\n", - "# 生成 Hamilton 量的矩阵信息\n", - "H = pauli_str_to_matrix(hamiltonian, N)" - ] + "metadata": { + "ExecuteTime": { + "end_time": "2021-04-30T09:12:57.604652Z", + "start_time": "2021-04-30T09:12:57.592553Z" + } + } }, { "cell_type": "markdown", - "metadata": {}, "source": [ "## 搭建量子神经网络\n", "\n", "- 在实现 SSVQE 的过程中，我们首先需要设计量子神经网络（quantum neural network, QNN），也即参数化量子电路。在本教程中，我们提供一个预设的适用于双量子比特的通用量子电路模板。理论上，该模板具有足够强大的表达能力可以表示任意的双量子比特逻辑运算 [5]。具体的实现方式是需要 3 个 $CNOT$ 门加上任意 15 个单比特旋转门 $\\in \\{R_y, R_z\\}$。\n", "\n", "- 初始化其中的变量参数，${\\bf{\\theta}}$ 代表我们量子神经网络中的参数组成的向量，一共有 15 个参数。" - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": 4, - "metadata": { - "ExecuteTime": { - "end_time": "2021-04-30T09:12:57.673600Z", - "start_time": "2021-04-30T09:12:57.664882Z" - } - }, - "outputs": [], + "execution_count": 9, "source": [ "THETA_SIZE = 15 # 量子神经网络中参数的数量\n", "\n", @@ -130,11 +123,17 @@ "\n", " # 返回量子神经网络的电路\n", " return cir" - ] + ], + "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2021-04-30T09:12:57.673600Z", + "start_time": "2021-04-30T09:12:57.664882Z" + } + } }, { "cell_type": "markdown", - "metadata": {}, "source": [ "## 配置训练模型——损失函数\n", "\n", @@ -149,18 +148,12 @@ "$$\n", "\\mathcal{L}(\\boldsymbol{\\theta}) = \\sum_{k=1}^{2^n}w_k*\\left\\langle {\\psi_k \\left( {\\bf{\\theta }} \\right)} \\right|H\\left| {\\psi_k \\left( {\\bf{\\theta }} \\right)} \\right\\rangle. \\tag{1}\n", "$$" - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": 5, - "metadata": { - "ExecuteTime": { - "end_time": "2021-04-30T09:12:58.591349Z", - "start_time": "2021-04-30T09:12:58.577120Z" - } - }, - "outputs": [], + "execution_count": 10, "source": [ "class Net(paddle.nn.Layer):\n", " def __init__(self, shape, dtype='float64'):\n", @@ -182,86 +175,62 @@ " loss_struct = paddle.real(matmul(matmul(dagger(U), H), U))\n", "\n", " # 输入计算基去计算每个子期望值，相当于取 U^dagger*H*U 的对角元 \n", - " loss_components = [\n", - " loss_struct[0][0],\n", - " loss_struct[1][1],\n", - " loss_struct[2][2],\n", - " loss_struct[3][3]\n", - " ]\n", + " loss_components = []\n", + " for i in range(len(loss_struct)):\n", + " loss_components.append(loss_struct[i][i])\n", " \n", " # 最终加权求和后的损失函数\n", - " loss = 4 * loss_components[0] + 3 * loss_components[1]\\\n", - " + 2 * loss_components[2] + 1 * loss_components[3]\n", + " loss = 0\n", + " for i in range(len(loss_components)):\n", + " weight = 4 - i\n", + " loss += weight * loss_components[i]\n", " \n", " return loss, loss_components, cir" - ] + ], + "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2021-04-30T09:12:58.591349Z", + "start_time": "2021-04-30T09:12:58.577120Z" + } + } }, { "cell_type": "markdown", - "metadata": {}, "source": [ "## 配置训练模型——模型参数\n", "在进行量子神经网络的训练之前，我们还需要进行一些训练的超参数设置，主要是学习速率（learning rate, LR）、迭代次数（iteration, ITR。这里我们设定学习速率为 0.3，迭代次数为 50 次。读者不妨自行调整来直观感受下超参数调整对训练效果的影响。" - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 11, + "source": [ + "ITR = 100 # 设置训练的总迭代次数\n", + "LR = 0.3 # 设置学习速率" + ], + "outputs": [], "metadata": { "ExecuteTime": { "end_time": "2021-04-30T09:12:59.351881Z", "start_time": "2021-04-30T09:12:59.343240Z" } - }, - "outputs": [], - "source": [ - "ITR = 100 # 设置训练的总迭代次数\n", - "LR = 0.3 # 设置学习速率" - ] + } }, { "cell_type": "markdown", - "metadata": {}, "source": [ "## 进行训练\n", "- 当训练模型的各项参数都设置完成后，我们将数据转化为 PaddlePaddle 动态图中的张量，进而进行量子神经网络的训练。\n", "- 过程中我们用的是 Adam Optimizer，也可以调用 PaddlePaddle 中提供的其他优化器。\n", "- 我们可以将训练过程中的每一轮 loss 打印出来。" - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": 7, - "metadata": { - "ExecuteTime": { - "end_time": "2021-04-30T09:13:07.503094Z", - "start_time": "2021-04-30T09:13:04.968574Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "iter: 10 loss: -4.5668\n", - "iter: 20 loss: -5.3998\n", - "iter: 30 loss: -5.6210\n", - "iter: 40 loss: -5.8872\n", - "iter: 50 loss: -5.9246\n", - "iter: 60 loss: -5.9471\n", - "iter: 70 loss: -5.9739\n", - "iter: 80 loss: -5.9833\n", - "iter: 90 loss: -5.9846\n", - "iter: 100 loss: -5.9848\n", - "\n", - "训练后的电路：\n", - "--U----X----Rz(-1.18)----*-----------------X----U--\n", - " | | | \n", - "--U----*----Ry(-0.03)----X----Ry(2.362)----*----U--\n", - " \n" - ] - } - ], + "execution_count": 13, "source": [ "paddle.seed(SEED)\n", " \n", @@ -292,11 +261,40 @@ " if itr == ITR:\n", " print(\"\\n训练后的电路：\")\n", " print(cir)" - ] + ], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "iter: 10 loss: -4.5668\n", + "iter: 20 loss: -5.3998\n", + "iter: 30 loss: -5.6210\n", + "iter: 40 loss: -5.8872\n", + "iter: 50 loss: -5.9246\n", + "iter: 60 loss: -5.9471\n", + "iter: 70 loss: -5.9739\n", + "iter: 80 loss: -5.9833\n", + "iter: 90 loss: -5.9846\n", + "iter: 100 loss: -5.9848\n", + "\n", + "训练后的电路：\n", + "--U----x----Rz(-1.18)----*-----------------x----U--\n", + " | | | \n", + "--U----*----Ry(-0.03)----x----Ry(2.362)----*----U--\n", + " \n" + ] + } + ], + "metadata": { + "ExecuteTime": { + "end_time": "2021-04-30T09:13:07.503094Z", + "start_time": "2021-04-30T09:13:04.968574Z" + } + } }, { "cell_type": "markdown", - "metadata": {}, "source": [ "## 测试效果\n", "\n", @@ -304,51 +302,64 @@ "- 理论值由 NumPy 中的工具来求解哈密顿量的各个本征值；\n", "- 我们将训练 QNN 得到的各个能级的能量和理想情况下的理论值进行比对。\n", "- 可以看到，SSVQE 训练输出的值与理想值高度接近。" - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": 8, - "metadata": { - "ExecuteTime": { - "end_time": "2021-04-30T09:13:07.569109Z", - "start_time": "2021-04-30T09:13:07.522441Z" - } - }, + "execution_count": 15, + "source": [ + "def output_ordinalvalue(num):\n", + " r\"\"\"\n", + " Convert to ordinal value\n", + "\n", + " Args:\n", + " num (int): input number\n", + "\n", + " Return:\n", + " (str): output ordinal value\n", + " \"\"\"\n", + " if num == 1:\n", + " return str(num) + \"st\"\n", + " elif num == 2:\n", + " return str(num) + \"nd\"\n", + " elif num == 3:\n", + " return str(num) + \"rd\"\n", + " else:\n", + " return str(num) + 'th'\n", + "\n", + "for i in range(len(loss_components)):\n", + " if i == 0:\n", + " print('The estimated ground state energy is: ', loss_components[i].numpy())\n", + " print('The theoretical ground state energy is: ', numpy.linalg.eigh(H)[0][i])\n", + " else:\n", + " print('The estimated {} excited state energy is: {}'.format(\n", + " output_ordinalvalue(i), loss_components[i].numpy())\n", + " )\n", + " print('The theoretical {} excited state energy is: {}'.format(\n", + " output_ordinalvalue(i), numpy.linalg.eigh(H)[0][i])\n", + " )" + ], "outputs": [ { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ - "The estimated ground state energy is: [-2.18762367]\n", - "The theoretical ground state energy: -2.18790201165885\n", - "The estimated 1st excited state energy is: [-0.13721027]\n", - "The theoretical 1st excited state energy: -0.13704127143749587\n", - "The estimated 2nd excited state energy is: [0.85251458]\n", - "The theoretical 2nd excited state energy: 0.8523274042087416\n", - "The estimated 3rd excited state energy is: [1.47231937]\n", - "The theoretical 3rd excited state energy: 1.4726158788876045\n" + "The estimated ground state energy is: [-2.18762366]\n", + "The theoretical ground state energy is: -2.18790201165885\n", + "The estimated 1st excited state energy is: [-0.13721024]\n", + "The theoretical 1st excited state energy is: -0.13704127143749587\n", + "The estimated 2nd excited state energy is: [0.85251457]\n", + "The theoretical 2nd excited state energy is: 0.8523274042087416\n", + "The estimated 3rd excited state energy is: [1.47231932]\n", + "The theoretical 3rd excited state energy is: 1.4726158788876045\n" ] } ], - "source": [ - "print('The estimated ground state energy is: ', loss_components[0].numpy())\n", - "print('The theoretical ground state energy: ', \n", - "numpy.linalg.eigh(H)[0][0])\n", - "\n", - "print('The estimated 1st excited state energy is: ', loss_components[1].numpy())\n", - "print('The theoretical 1st excited state energy: ', numpy.linalg.eigh(H)[0][1])\n", - "\n", - "print('The estimated 2nd excited state energy is: ', loss_components[2].numpy())\n", - "print('The theoretical 2nd excited state energy: ', numpy.linalg.eigh(H)[0][2])\n", - "\n", - "print('The estimated 3rd excited state energy is: ', loss_components[3].numpy())\n", - "print('The theoretical 3rd excited state energy: ', numpy.linalg.eigh(H)[0][3])" - ] + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "_______\n", "\n", @@ -363,14 +374,14 @@ "[4] Nakanishi, K. M., Mitarai, K. & Fujii, K. Subspace-search variational quantum eigensolver for excited states. [Phys. Rev. Res. 1, 033062 (2019).](https://journals.aps.org/prresearch/pdf/10.1103/PhysRevResearch.1.033062)\n", "\n", "[5] Vatan, F. & Williams, C. Optimal quantum circuits for general two-qubit gates. [Phys. Rev. A 69, 032315 (2004).](https://journals.aps.org/pra/abstract/10.1103/PhysRevA.69.032315)" - ] + ], + "metadata": {} } ], "metadata": { "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" + "name": "python3", + "display_name": "Python 3.8.10 64-bit ('paddle_quantum_test': conda)" }, "language_info": { "codemirror_mode": { @@ -382,7 +393,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.3" + "version": "3.8.10" }, "toc": { "base_numbering": 1, @@ -396,8 +407,11 @@ "toc_position": {}, "toc_section_display": true, "toc_window_display": false + }, + "interpreter": { + "hash": "1ba3360425d54dc61cc146cb8ddc529b6d51be6719655a3ca16cefddffc9595a" } }, "nbformat": 4, "nbformat_minor": 4 -} +} \ No newline at end of file diff --git a/tutorial/quantum_simulation/SSVQE_EN.ipynb b/tutorial/quantum_simulation/SSVQE_EN.ipynb index 3ac9752..3c92b15 100644 --- a/tutorial/quantum_simulation/SSVQE_EN.ipynb +++ b/tutorial/quantum_simulation/SSVQE_EN.ipynb @@ -2,7 +2,6 @@ "cells": [ { "cell_type": "markdown", - "metadata": {}, "source": [ "# Subspace-search Variational Quantum Eigensolver\n", "\n", @@ -13,18 +12,12 @@ "- In this tutorial, we will show how to train a quantum neural network (QNN) through Paddle Quantum to find the entire energy spectrum of a quantum system.\n", "\n", "- First, import the following packages." - ] + ], + "metadata": {} }, { "cell_type": "code", "execution_count": 1, - "metadata": { - "ExecuteTime": { - "end_time": "2021-04-30T09:12:27.747028Z", - "start_time": "2021-04-30T09:12:25.171248Z" - } - }, - "outputs": [], "source": [ "import numpy\n", "from numpy import pi as PI\n", @@ -32,11 +25,17 @@ "from paddle import matmul\n", "from paddle_quantum.circuit import UAnsatz\n", "from paddle_quantum.utils import random_pauli_str_generator, pauli_str_to_matrix, dagger" - ] + ], + "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2021-04-30T09:12:27.747028Z", + "start_time": "2021-04-30T09:12:25.171248Z" + } + } }, { "cell_type": "markdown", - "metadata": {}, "source": [ "## Background\n", "\n", @@ -47,73 +46,67 @@ "\n", "- For a specific molecule that needs to be analyzed, we need its geometry, charge, and spin multiplicity to obtain the Hamiltonian (in Pauli products form) describing the system. Specifically, through our built-in quantum chemistry toolkit, fermionic-to-qubit mapping technology can be used to output the qubit Hamiltonian.\n", "- As a simple demonstration of SSVQE, we provide a random 2-qubit Hamiltonian." - ] + ], + "metadata": {} }, { "cell_type": "code", "execution_count": 2, + "source": [ + "N = 2 # Number of qubits\n", + "SEED = 14 # Fixed random seed" + ], + "outputs": [], "metadata": { "ExecuteTime": { "end_time": "2021-04-30T09:12:27.773417Z", "start_time": "2021-04-30T09:12:27.752568Z" } - }, - "outputs": [], - "source": [ - "N = 2 # Number of qubits\n", - "SEED = 14 # Fixed random seed" - ] + } }, { "cell_type": "code", "execution_count": 3, - "metadata": { - "ExecuteTime": { - "end_time": "2021-04-30T09:12:27.804177Z", - "start_time": "2021-04-30T09:12:27.779339Z" - } - }, + "source": [ + "# Generate random Hamiltonian represented by Pauli string\n", + "numpy.random.seed(SEED)\n", + "hamiltonian = random_pauli_str_generator(N, terms=10)\n", + "print(\"Random Hamiltonian in Pauli string format = \\n\", hamiltonian)\n", + "\n", + "# Generate matrix representation of Hamiltonian\n", + "H = pauli_str_to_matrix(hamiltonian, N)" + ], "outputs": [ { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ "Random Hamiltonian in Pauli string format = \n", " [[0.9152074787317819, 'x1,y0'], [-0.2717604556798945, 'z0'], [0.3628495008719168, 'x0'], [-0.5050129214094752, 'x1'], [-0.6971554357833791, 'y0,x1'], [0.8651151857574237, 'x0,y1'], [0.7409989105435002, 'y0'], [-0.39981603921243236, 'y0'], [0.06862640764702, 'z0'], [-0.7647553733438246, 'y1']]\n" ] } ], - "source": [ - "# Generate random Hamiltonian represented by Pauli string\n", - "numpy.random.seed(SEED)\n", - "hamiltonian = random_pauli_str_generator(N, terms=10)\n", - "print(\"Random Hamiltonian in Pauli string format = \\n\", hamiltonian)\n", - "\n", - "# Generate matrix representation of Hamiltonian\n", - "H = pauli_str_to_matrix(hamiltonian, N)" - ] + "metadata": { + "ExecuteTime": { + "end_time": "2021-04-30T09:12:27.804177Z", + "start_time": "2021-04-30T09:12:27.779339Z" + } + } }, { "cell_type": "markdown", - "metadata": {}, "source": [ "## Building a quantum neural network\n", "\n", "- To implement SSVQE, we first need to design a QNN $U(\\theta)$ (parameterized quantum circuit). In this tutorial, we provide a predefined universal quantum circuit template suitable for 2 qubits. Theoretically, this template has enough expressibility to simulate arbitrary 2-qubit unitary operation [5]. The specific implementation requires 3 $CNOT$ gates plus 15 single-qubit rotation gates $\\in \\{R_y, R_z\\}$.\n", "\n", "- One can randomly initialize the QNN parameters ${\\bf{\\vec{\\theta }}}$ containing 15 parameters." - ] + ], + "metadata": {} }, { "cell_type": "code", "execution_count": 4, - "metadata": { - "ExecuteTime": { - "end_time": "2021-04-30T09:12:27.822250Z", - "start_time": "2021-04-30T09:12:27.809696Z" - } - }, - "outputs": [], "source": [ "THETA_SIZE = 15 # The number of parameters in the quantum neural network\n", "\n", @@ -129,11 +122,17 @@ "\n", " # Return the circuit of the quantum neural network\n", " return cir" - ] + ], + "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2021-04-30T09:12:27.822250Z", + "start_time": "2021-04-30T09:12:27.809696Z" + } + } }, { "cell_type": "markdown", - "metadata": {}, "source": [ "## Training model and loss function\n", "\n", @@ -148,18 +147,12 @@ "$$\n", "\\mathcal{L}(\\boldsymbol{\\theta}) = \\sum_{k=1}^{2^n}w_k*\\left\\langle {\\psi_k \\left( {\\bf{\\theta }} \\right)} \\right|H\\left| {\\psi_k \\left( {\\bf{\\theta }} \\right)} \\right\\rangle. \\tag{1}\n", "$$" - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": 5, - "metadata": { - "ExecuteTime": { - "end_time": "2021-04-30T09:12:28.432737Z", - "start_time": "2021-04-30T09:12:28.423798Z" - } - }, - "outputs": [], + "execution_count": 6, "source": [ "class Net(paddle.nn.Layer):\n", " def __init__(self, shape, dtype='float64'):\n", @@ -182,87 +175,63 @@ "\n", " # Enter the computational basis to calculate the expected value \n", " # which is equivalent to taking the diagonal element of U^dagger*H*U\n", - " loss_components = [\n", - " loss_struct[0][0],\n", - " loss_struct[1][1],\n", - " loss_struct[2][2],\n", - " loss_struct[3][3]\n", - " ]\n", + " loss_components = []\n", + " for i in range(len(loss_struct)):\n", + " loss_components.append(loss_struct[i][i])\n", " \n", " # Weighted summation of loss function\n", - " loss = 4 * loss_components[0] + 3 * loss_components[1]\\\n", - " + 2 * loss_components[2] + 1 * loss_components[3]\n", + " loss = 0\n", + " for i in range(len(loss_components)):\n", + " weight = 4 - i\n", + " loss += weight * loss_components[i]\n", " \n", " return loss, loss_components, cir" - ] + ], + "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2021-04-30T09:12:28.432737Z", + "start_time": "2021-04-30T09:12:28.423798Z" + } + } }, { "cell_type": "markdown", - "metadata": {}, "source": [ "## Hyper-parameters\n", "\n", "Before training the quantum neural network, we also need to set up several hyper-parameters, mainly the learning rate LR, the number of iterations ITR. Here we set the learning rate to be LR = 0.3 and the number of iterations ITR = 50. One can adjust these hyper-parameters accordingly and check how they influence the training performance." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, + "source": [ + "ITR = 100 # Set the total number of iterations of training\n", + "LR = 0.3 # Set the learning rate" + ], + "outputs": [], "metadata": { "ExecuteTime": { "end_time": "2021-04-30T09:12:29.579180Z", "start_time": "2021-04-30T09:12:29.575632Z" } - }, - "outputs": [], - "source": [ - "ITR = 100 # Set the total number of iterations of training\n", - "LR = 0.3 # Set the learning rate" - ] + } }, { "cell_type": "markdown", - "metadata": {}, "source": [ "## Training process\n", "\n", "- After setting all the parameters of SSVQE model, we need to convert all the data into Tensor in the PaddlePaddle, and then train the quantum neural network.\n", "- We use Adam Optimizer in training, and one can also call other optimizers provided in PaddlePaddle." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": 8, - "metadata": { - "ExecuteTime": { - "end_time": "2021-04-30T09:12:44.010556Z", - "start_time": "2021-04-30T09:12:41.952650Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "iter: 10 loss: -4.5668\n", - "iter: 20 loss: -5.3998\n", - "iter: 30 loss: -5.6210\n", - "iter: 40 loss: -5.8872\n", - "iter: 50 loss: -5.9246\n", - "iter: 60 loss: -5.9471\n", - "iter: 70 loss: -5.9739\n", - "iter: 80 loss: -5.9833\n", - "iter: 90 loss: -5.9846\n", - "iter: 100 loss: -5.9848\n", - "\n", - "The trained circuit:\n", - "--U----X----Rz(-1.18)----*-----------------X----U--\n", - " | | | \n", - "--U----*----Ry(-0.03)----X----Ry(2.362)----*----U--\n", - " \n" - ] - } - ], + "execution_count": 9, "source": [ "paddle.seed(SEED)\n", "\n", @@ -293,11 +262,40 @@ " if itr == ITR:\n", " print(\"\\nThe trained circuit:\")\n", " print(cir)" - ] + ], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "iter: 10 loss: -4.5668\n", + "iter: 20 loss: -5.3998\n", + "iter: 30 loss: -5.6210\n", + "iter: 40 loss: -5.8872\n", + "iter: 50 loss: -5.9246\n", + "iter: 60 loss: -5.9471\n", + "iter: 70 loss: -5.9739\n", + "iter: 80 loss: -5.9833\n", + "iter: 90 loss: -5.9846\n", + "iter: 100 loss: -5.9848\n", + "\n", + "The trained circuit:\n", + "--U----x----Rz(-1.18)----*-----------------x----U--\n", + " | | | \n", + "--U----*----Ry(-0.03)----x----Ry(2.362)----*----U--\n", + " \n" + ] + } + ], + "metadata": { + "ExecuteTime": { + "end_time": "2021-04-30T09:12:44.010556Z", + "start_time": "2021-04-30T09:12:41.952650Z" + } + } }, { "cell_type": "markdown", - "metadata": {}, "source": [ "## Benchmarking\n", "\n", @@ -305,51 +303,69 @@ "- The theoretical Hamiltonian eigenvalues are solved by the linear algebra package in NumPy;\n", "- We compare the energy of each energy level obtained by training QNN with the theoretical value.\n", "- It can be seen that the training output is very close to the exact value." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": 9, - "metadata": { - "ExecuteTime": { - "end_time": "2021-04-30T09:12:45.991342Z", - "start_time": "2021-04-30T09:12:45.976287Z" - } - }, + "execution_count": 10, + "source": [ + "def output_ordinalvalue(num):\n", + " r\"\"\"\n", + " Convert to ordinal value\n", + "\n", + " Args:\n", + " num (int): input number\n", + "\n", + " Return:\n", + " (str): output ordinal value\n", + " \"\"\"\n", + " if num == 1:\n", + " return str(num) + \"st\"\n", + " elif num == 2:\n", + " return str(num) + \"nd\"\n", + " elif num == 3:\n", + " return str(num) + \"rd\"\n", + " else:\n", + " return str(num) + 'th'\n", + "\n", + "for i in range(len(loss_components)):\n", + " if i == 0:\n", + " print('The estimated ground state energy is: ', loss_components[i].numpy())\n", + " print('The theoretical ground state energy is: ', numpy.linalg.eigh(H)[0][i])\n", + " else:\n", + " print('The estimated {} excited state energy is: {}'.format(\n", + " output_ordinalvalue(i), loss_components[i].numpy())\n", + " )\n", + " print('The theoretical {} excited state energy is: {}'.format(\n", + " output_ordinalvalue(i), numpy.linalg.eigh(H)[0][i])\n", + " )" + ], "outputs": [ { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ - "The estimated ground state energy is: [-2.18762367]\n", - "The theoretical ground state energy: -2.18790201165885\n", - "The estimated 1st excited state energy is: [-0.13721027]\n", - "The theoretical 1st excited state energy: -0.13704127143749587\n", - "The estimated 2nd excited state energy is: [0.85251458]\n", - "The theoretical 2nd excited state energy: 0.8523274042087416\n", - "The estimated 3rd excited state energy is: [1.47231937]\n", - "The theoretical 3rd excited state energy: 1.4726158788876045\n" + "The estimated ground state energy is: [-2.18762366]\n", + "The theoretical ground state energy is: -2.18790201165885\n", + "The estimated 1st excited state energy is: [-0.13721024]\n", + "The theoretical 1st excited state energy is: -0.13704127143749587\n", + "The estimated 2nd excited state energy is: [0.85251457]\n", + "The theoretical 2nd excited state energy is: 0.8523274042087416\n", + "The estimated 3rd excited state energy is: [1.47231932]\n", + "The theoretical 3rd excited state energy is: 1.4726158788876045\n" ] } ], - "source": [ - "print('The estimated ground state energy is: ', loss_components[0].numpy())\n", - "print('The theoretical ground state energy: ', \n", - "numpy.linalg.eigh(H)[0][0])\n", - "\n", - "print('The estimated 1st excited state energy is: ', loss_components[1].numpy())\n", - "print('The theoretical 1st excited state energy: ', numpy.linalg.eigh(H)[0][1])\n", - "\n", - "print('The estimated 2nd excited state energy is: ', loss_components[2].numpy())\n", - "print('The theoretical 2nd excited state energy: ', numpy.linalg.eigh(H)[0][2])\n", - "\n", - "print('The estimated 3rd excited state energy is: ', loss_components[3].numpy())\n", - "print('The theoretical 3rd excited state energy: ', numpy.linalg.eigh(H)[0][3])" - ] + "metadata": { + "ExecuteTime": { + "end_time": "2021-04-30T09:12:45.991342Z", + "start_time": "2021-04-30T09:12:45.976287Z" + } + } }, { "cell_type": "markdown", - "metadata": {}, "source": [ "_______\n", "\n", @@ -364,14 +380,14 @@ "[4] Nakanishi, K. M., Mitarai, K. & Fujii, K. Subspace-search variational quantum eigensolver for excited states. [Phys. Rev. Res. 1, 033062 (2019).](https://journals.aps.org/prresearch/pdf/10.1103/PhysRevResearch.1.033062)\n", "\n", "[5] Vatan, F. & Williams, C. Optimal quantum circuits for general two-qubit gates. [Phys. Rev. A 69, 032315 (2004).](https://journals.aps.org/pra/abstract/10.1103/PhysRevA.69.032315)" - ] + ], + "metadata": {} } ], "metadata": { "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" + "name": "python3", + "display_name": "Python 3.8.10 64-bit ('paddle_quantum_test': conda)" }, "language_info": { "codemirror_mode": { @@ -383,7 +399,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.3" + "version": "3.8.10" }, "toc": { "base_numbering": 1, @@ -397,8 +413,11 @@ "toc_position": {}, "toc_section_display": true, "toc_window_display": false + }, + "interpreter": { + "hash": "1ba3360425d54dc61cc146cb8ddc529b6d51be6719655a3ca16cefddffc9595a" } }, "nbformat": 4, "nbformat_minor": 4 -} +} \ No newline at end of file diff --git a/tutorial/quantum_simulation/VQE_CN.ipynb b/tutorial/quantum_simulation/VQE_CN.ipynb index 9932ae1..40db47a 100644 --- a/tutorial/quantum_simulation/VQE_CN.ipynb +++ b/tutorial/quantum_simulation/VQE_CN.ipynb @@ -22,7 +22,7 @@ "\\tag{1}\n", "$$\n", "\n", - "其中 $E_0$ 表示该系统的基态能量。从数值分析的角度来看，该问题可以被理解为求解一个**离散化**哈密顿量 $H$（厄米矩阵）的最小本征值 $\\lambda_{\\min}$ 和其对应的本征向量 $|\\Psi_0\\rangle$。具体的离散化过程是如何通过建立模型实现的，这属于量子化学的专业领域范畴。精确地解释该过程需要很长的篇幅，这超过了本教程所能处理的范围。我们会在下一节背景知识模块粗略的介绍一下相关知识，感兴趣的读者可以参考 `量子化学: 基本原理和从头计算法`系列丛书 [5]。通常来说，为了能在量子设备上处理量子化学问题，哈密顿量 $H$ 会被表示成为泡利算符 $\\{X,Y,Z\\}$ 的加权求和形式。\n", + "其中 $E_0$ 表示该系统的基态能量。从数值分析的角度来看，该问题可以被理解为求解一个**离散化**哈密顿量 $H$（埃尔米特矩阵）的最小本征值 $\\lambda_{\\min}$ 和其对应的本征向量 $|\\Psi_0\\rangle$。具体的离散化过程是如何通过建立模型实现的，这属于量子化学的专业领域范畴。精确地解释该过程需要很长的篇幅，这超过了本教程所能处理的范围。我们会在下一节背景知识模块粗略的介绍一下相关知识，感兴趣的读者可以参考 `量子化学: 基本原理和从头计算法`系列丛书 [5]。通常来说，为了能在量子设备上处理量子化学问题，哈密顿量 $H$ 会被表示成为泡利算符 $\\{X,Y,Z\\}$ 的加权求和形式。\n", "\n", "$$\n", "H = \\sum_k c_k ~ \\bigg( \\bigotimes_{j=0}^{M-1} \\sigma_j^{(k)} \\bigg),\n", @@ -631,7 +631,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.0" + "version": "3.9.5" }, "toc": { "base_numbering": 1, -- GitLab